pthreads mutex vs semaphore

pthreads Mutex vs. Semaphore: Understanding Synchronization Primitives

Explore the fundamental differences and use cases of pthreads mutexes and semaphores for thread synchronization in C/C++ on Linux.

In concurrent programming, managing access to shared resources is crucial to prevent data corruption and ensure program correctness. POSIX threads (pthreads) provide several synchronization primitives, with mutexes and semaphores being two of the most commonly used. While both serve to control access, they operate on different principles and are suited for distinct scenarios. This article will delve into the characteristics, usage, and key differences between pthreads mutexes and semaphores.

Understanding Mutexes (Mutual Exclusion)

A mutex, short for mutual exclusion, is a locking mechanism used to protect a critical section of code. Only one thread can hold a mutex at any given time. When a thread acquires a mutex, it gains exclusive access to the protected resource. If another thread attempts to acquire the same mutex, it will be blocked until the mutex is released by the owning thread. Mutexes are primarily used for protecting shared data structures from race conditions.

flowchart TD
    A[Thread A wants resource] --> B{Mutex available?}
    B -- Yes --> C[Thread A acquires Mutex]
    C --> D[Thread A accesses resource]
    D --> E[Thread A releases Mutex]
    E --> F[Resource available]
    B -- No --> G[Thread A waits]
    G --> B

Flowchart of a thread acquiring and releasing a mutex.

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

pthread_mutex_t my_mutex = PTHREAD_MUTEX_INITIALIZER;
int shared_data = 0;

void* increment_data(void* arg) {
    for (int i = 0; i < 100000; ++i) {
        pthread_mutex_lock(&my_mutex);
        shared_data++;
        pthread_mutex_unlock(&my_mutex);
    }
    return NULL;
}

int main() {
    pthread_t t1, t2;
    pthread_create(&t1, NULL, increment_data, NULL);
    pthread_create(&t2, NULL, increment_data, NULL);
    pthread_join(t1, NULL);
    pthread_join(t2, NULL);
    printf("Final shared_data: %d\n", shared_data);
    pthread_mutex_destroy(&my_mutex);
    return 0;
}

Understanding Semaphores

A semaphore is a signaling mechanism that controls access to a resource with a limited number of instances. Unlike a mutex, which is binary (locked/unlocked), a semaphore can have an integer value greater than one. This value represents the number of available resources. When a thread wants to access a resource, it performs a 'wait' (decrement) operation on the semaphore. If the semaphore's value is greater than zero, the thread proceeds and the value is decremented. If the value is zero, the thread blocks until another thread performs a 'post' (increment) operation, releasing a resource. Semaphores are often used for resource counting or for signaling between threads (e.g., producer-consumer problems).

flowchart TD
    A[Thread wants resource] --> B{Semaphore value > 0?}
    B -- Yes --> C[Decrement semaphore]
    C --> D[Access resource]
    D --> E[Increment semaphore]
    E --> F[Resource released]
    B -- No --> G[Thread waits]
    G --> B

Flowchart of a thread using a semaphore for resource access.

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

sem_t my_semaphore;
int buffer[5];
int in = 0, out = 0;

void* producer(void* arg) {
    for (int i = 0; i < 10; ++i) {
        // Produce item
        int item = i;
        sem_wait(&my_semaphore); // Wait for an empty slot
        buffer[in] = item;
        printf("Produced: %d at %d\n", item, in);
        in = (in + 1) % 5;
        sem_post(&my_semaphore); // Signal that a slot is filled
    }
    return NULL;
}

void* consumer(void* arg) {
    for (int i = 0; i < 10; ++i) {
        sem_wait(&my_semaphore); // Wait for a filled slot
        int item = buffer[out];
        printf("Consumed: %d from %d\n", item, out);
        out = (out + 1) % 5;
        sem_post(&my_semaphore); // Signal that a slot is empty
    }
    return NULL;
}

int main() {
    // Initialize semaphore with initial value (e.g., 5 for buffer size)
    sem_init(&my_semaphore, 0, 5);

    pthread_t prod_t, cons_t;
    pthread_create(&prod_t, NULL, producer, NULL);
    pthread_create(&cons_t, NULL, consumer, NULL);

    pthread_join(prod_t, NULL);
    pthread_join(cons_t, NULL);

    sem_destroy(&my_semaphore);
    return 0;
}

Key Differences and Use Cases

The primary distinction lies in their purpose and behavior. Mutexes are for mutual exclusion, ensuring only one thread is in a critical section at a time. Semaphores are for signaling and resource counting, allowing a specified number of threads to access a resource concurrently or to signal events between threads. A binary semaphore (initialized to 1) can behave like a mutex, but a mutex cannot behave like a counting semaphore.

Comparison of Mutex vs. Semaphore Characteristics

Here's a summary of their key differences:

Mutex

• Purpose: Mutual exclusion (protecting critical sections).
• State: Locked/Unlocked (binary).
• Ownership: Owned by the thread that locks it. Only the owner can unlock.
• Use Cases: Protecting shared variables, data structures, ensuring atomicity of operations.
• Complexity: Generally simpler for basic critical section protection.

Semaphore

• Purpose: Signaling, resource counting, controlling access to a pool of resources.
• State: Integer value (can be > 1).
• Ownership: No ownership. Any thread can increment (sem_post) or decrement (sem_wait).
• Use Cases: Producer-consumer problems, limiting concurrent access to a resource pool, inter-thread signaling.
• Complexity: Can be more complex due to counting and signaling logic.

Choosing between a mutex and a semaphore depends entirely on the synchronization problem you are trying to solve. For simple critical section protection, a mutex is usually the more straightforward and appropriate choice. For managing a pool of resources or coordinating complex inter-thread communication, semaphores offer the necessary flexibility.