When to Use Named vs Unnamed Semaphores

sem_init() — Initialize an Unnamed Semaphore

#include <semaphore.h>

int sem_init(sem_t *sem, int pshared, unsigned int value);

/* Returns: 0 on success, -1 on error */

sem_destroy() — Clean Up an Unnamed Semaphore

#include <semaphore.h>

int sem_destroy(sem_t *sem);

/* Returns: 0 on success, -1 on error */

sem_destroy() destroys an unnamed semaphore, freeing any resources the kernel may have associated with it. After calling it, the sem_t variable is uninitialized and must not be used unless re-initialized.

Where to Place the sem_t Variable

Example 1: Thread Synchronization with Unnamed Semaphore

The most common use case: synchronizing multiple threads in the same process.

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

/* Global unnamed semaphore shared by all threads */
static sem_t mutex_sem;
static int shared_data = 0;

void *writer_thread(void *arg)
{
    int id = *(int *)arg;

    for (int i = 0; i < 5; i++) {
        sem_wait(&mutex_sem);      /* acquire lock */
        shared_data++;
        printf("Thread %d: wrote shared_data = %d\n", id, shared_data);
        sem_post(&mutex_sem);      /* release lock */
    }
    return NULL;
}

int main(void)
{
    pthread_t t1, t2, t3;
    int ids[3] = {1, 2, 3};

    /* Initialize unnamed semaphore:
     * pshared=0 (thread-shared), value=1 (binary/mutex) */
    if (sem_init(&mutex_sem, 0, 1) == -1) {
        perror("sem_init");
        exit(EXIT_FAILURE);
    }

    /* Create 3 threads */
    pthread_create(&t1, NULL, writer_thread, &ids[0]);
    pthread_create(&t2, NULL, writer_thread, &ids[1]);
    pthread_create(&t3, NULL, writer_thread, &ids[2]);

    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    pthread_join(t3, NULL);

    printf("Final shared_data (should be 15): %d\n", shared_data);

    /* Destroy when no longer needed */
    sem_destroy(&mutex_sem);
    return 0;
}

Example 2: Producer-Consumer with Unnamed Semaphores

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

#define SLOTS    4
#define ITEMS   12

static sem_t sem_empty;   /* counts empty slots */
static sem_t sem_full;    /* counts filled slots */
static sem_t sem_mutex;   /* protects buffer */

static int buffer[SLOTS];
static int in_pos = 0, out_pos = 0;

void *producer(void *arg)
{
    for (int i = 0; i < ITEMS; i++) {
        sem_wait(&sem_empty);
        sem_wait(&sem_mutex);

        buffer[in_pos] = i * 10;
        printf("[Producer] Added %d at slot %d\n", i * 10, in_pos);
        in_pos = (in_pos + 1) % SLOTS;

        sem_post(&sem_mutex);
        sem_post(&sem_full);
    }
    return NULL;
}

void *consumer(void *arg)
{
    for (int i = 0; i < ITEMS; i++) {
        sem_wait(&sem_full);
        sem_wait(&sem_mutex);

        int item = buffer[out_pos];
        printf("[Consumer] Got %d from slot %d\n", item, out_pos);
        out_pos = (out_pos + 1) % SLOTS;

        sem_post(&sem_mutex);
        sem_post(&sem_empty);
    }
    return NULL;
}

int main(void)
{
    pthread_t prod, cons;

    /* Initialize all three semaphores */
    sem_init(&sem_empty, 0, SLOTS);   /* SLOTS empty slots initially */
    sem_init(&sem_full,  0, 0);       /* 0 full slots initially */
    sem_init(&sem_mutex, 0, 1);       /* mutex: initially unlocked */

    pthread_create(&prod, NULL, producer, NULL);
    pthread_create(&cons, NULL, consumer, NULL);

    pthread_join(prod, NULL);
    pthread_join(cons, NULL);

    /* Cleanup */
    sem_destroy(&sem_empty);
    sem_destroy(&sem_full);
    sem_destroy(&sem_mutex);
    return 0;
}

Example 3: Process-Shared Semaphore via mmap()

For sharing between a parent and child process, place the semaphore in anonymous shared memory using mmap() with MAP_SHARED | MAP_ANONYMOUS.

#include <semaphore.h>
#include <sys/mman.h>
#include <sys/wait.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

int main(void)
{
    sem_t *sem;
    pid_t pid;

    /*
     * Allocate shared memory for the sem_t variable.
     * MAP_SHARED + MAP_ANONYMOUS: visible to parent AND child after fork.
     */
    sem = mmap(NULL, sizeof(sem_t),
               PROT_READ | PROT_WRITE,
               MAP_SHARED | MAP_ANONYMOUS,
               -1, 0);
    if (sem == MAP_FAILED) {
        perror("mmap");
        exit(EXIT_FAILURE);
    }

    /*
     * Initialize semaphore IN the shared memory.
     * pshared=1: process-shared
     * value=0: starts locked (parent waits for child)
     */
    if (sem_init(sem, 1, 0) == -1) {
        perror("sem_init");
        exit(EXIT_FAILURE);
    }

    pid = fork();
    if (pid == -1) { perror("fork"); exit(1); }

    if (pid == 0) {
        /* CHILD: do work, then signal parent */
        printf("Child (pid %d): doing computation...\n", getpid());
        sleep(2);
        printf("Child: finished, signaling parent\n");
        sem_post(sem);   /* wake parent */
        exit(0);
    } else {
        /* PARENT: wait for child to finish */
        printf("Parent: waiting for child to finish...\n");
        sem_wait(sem);
        printf("Parent: child finished! Continuing.\n");
        wait(NULL);

        /* Cleanup */
        sem_destroy(sem);
        munmap(sem, sizeof(sem_t));
    }

    return 0;
}

Example 4: sem_t Embedded in a Struct

A common pattern is embedding a semaphore directly inside a data structure that the semaphore protects.

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

#define BUF_SIZE 256

/* A thread-safe message queue with embedded semaphore */
typedef struct {
    char    data[BUF_SIZE];
    int     has_message;    /* 1 if a message is waiting */
    sem_t   sem;            /* semaphore embedded in struct */
} msg_box_t;

msg_box_t mailbox;

void *sender(void *arg)
{
    /* Wait until mailbox is empty */
    /* (in a full implementation you'd have a second sem for full/empty) */
    sleep(1);
    strncpy(mailbox.data, "Hello from sender!", BUF_SIZE - 1);
    mailbox.has_message = 1;
    printf("Sender: message placed\n");
    sem_post(&mailbox.sem);   /* signal receiver */
    return NULL;
}

void *receiver(void *arg)
{
    printf("Receiver: waiting for message...\n");
    sem_wait(&mailbox.sem);   /* wait for message */
    printf("Receiver: got message: '%s'\n", mailbox.data);
    return NULL;
}

int main(void)
{
    pthread_t s, r;

    /* Initialize semaphore IN the struct: pshared=0, value=0 */
    if (sem_init(&mailbox.sem, 0, 0) == -1) {
        perror("sem_init");
        exit(1);
    }
    mailbox.has_message = 0;

    pthread_create(&r, NULL, receiver, NULL);
    pthread_create(&s, NULL, sender, NULL);

    pthread_join(r, NULL);
    pthread_join(s, NULL);

    sem_destroy(&mailbox.sem);
    return 0;
}

Common Errors with Unnamed Semaphores

Chapter Summary: All POSIX Semaphore Functions