When a process opens a named semaphore using sem_open(), the operating system internally records the link between that process and the semaphore. Think of it as the OS keeping a reference count — how many processes currently have this semaphore open.

Calling sem_close() tells the OS: “This process is done using this semaphore.” It does three things:

• Terminates the association between this process and the semaphore
• Frees any OS resources allocated for this process’s access to the semaphore
• Decrements the internal reference count of the semaphore

Function Signature

#include <semaphore.h>

int sem_close(sem_t *sem);
/* Returns 0 on success, or -1 on error */

Important Behaviour

You do not need to explicitly call sem_close() in all situations. Named semaphores are automatically closed in two cases:

• When the process terminates (normal exit or crash)
• When the process calls exec() to execute a new program

However, it is always good practice to call sem_close() explicitly. This frees resources promptly and avoids resource leaks in long-running processes.

Code Example – Closing a Semaphore

#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>
#include <fcntl.h>   /* O_CREAT, O_RDWR */
#include <sys/stat.h>

int main(void)
{
    sem_t *sem;

    /* Open an existing named semaphore (must already exist) */
    sem = sem_open("/my_semaphore", 0);
    if (sem == SEM_FAILED) {
        perror("sem_open");
        exit(EXIT_FAILURE);
    }

    printf("Semaphore opened successfully.\n");

    /* ... do some work with the semaphore ... */

    /* Close the semaphore when done — releases resources for this process */
    if (sem_close(sem) == -1) {
        perror("sem_close");
        exit(EXIT_FAILURE);
    }

    printf("Semaphore closed. It still exists in the system.\n");
    printf("Use sem_unlink() to actually delete it.\n");

    return EXIT_SUCCESS;
}

sem_unlink() removes the named semaphore from the filesystem. It is similar in concept to unlink() for files. However, like file unlinking, the semaphore is not immediately destroyed if other processes still have it open.

The exact behaviour is:

• The name is removed from the filesystem immediately
• No new processes can open the semaphore using this name
• The semaphore object is destroyed only when all currently open references are closed

Function Signature

#include <semaphore.h>

int sem_unlink(const char *name);
/* Returns 0 on success, or -1 on error */

Code Example – Unlinking a Semaphore

#include <stdio.h>
#include <stdlib.h>
#include <semaphore.h>

int main(int argc, char *argv[])
{
    if (argc != 2) {
        fprintf(stderr, "Usage: %s <sem-name>\n", argv[0]);
        exit(EXIT_FAILURE);
    }

    /* Remove the named semaphore identified by argv[1] */
    if (sem_unlink(argv[1]) == -1) {
        perror("sem_unlink");
        exit(EXIT_FAILURE);
    }

    printf("Semaphore '%s' unlinked successfully.\n", argv[1]);
    return EXIT_SUCCESS;
}

Code Example – Full Lifecycle (Create → Use → Close → Unlink)

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <semaphore.h>
#include <fcntl.h>
#include <sys/stat.h>

#define SEM_NAME "/demo_sem"

int main(void)
{
    sem_t *sem;

    /* Step 1: Create and open the semaphore with initial value 1 */
    sem = sem_open(SEM_NAME, O_CREAT | O_EXCL, S_IRUSR | S_IWUSR, 1);
    if (sem == SEM_FAILED) {
        perror("sem_open");
        exit(EXIT_FAILURE);
    }
    printf("Step 1: Semaphore created: %s\n", SEM_NAME);

    /* Step 2: Use the semaphore (wait = lock, post = unlock) */
    if (sem_wait(sem) == -1) {
        perror("sem_wait");
        exit(EXIT_FAILURE);
    }
    printf("Step 2: Entered critical section\n");

    /* ... critical section work ... */

    if (sem_post(sem) == -1) {
        perror("sem_post");
        exit(EXIT_FAILURE);
    }
    printf("Step 3: Exited critical section\n");

    /* Step 4: Close this process's access */
    if (sem_close(sem) == -1) {
        perror("sem_close");
        exit(EXIT_FAILURE);
    }
    printf("Step 4: Semaphore closed\n");

    /* Step 5: Remove the semaphore from the system */
    if (sem_unlink(SEM_NAME) == -1) {
        perror("sem_unlink");
        exit(EXIT_FAILURE);
    }
    printf("Step 5: Semaphore unlinked and destroyed\n");

    return EXIT_SUCCESS;
}