Process Synchronization — Mutex, Semaphores, Monitors

🎯 Learning Objectives

• Explain the critical section problem and its three requirements
• Implement mutual exclusion using mutex locks and semaphores
• Differentiate between counting and binary semaphores
• Solve classic synchronization problems using semaphores and monitors
• Understand the ABA problem and spinlock tradeoffs

1. The Critical Section Problem

1.1 Intuition

1.2 Race Condition Example

c
int counter = 0;
// Thread 1                    // Thread 2
counter++;                     counter++;
// Load counter (0)            // Load counter (0)
// Increment to 1              // Increment to 1
// Store counter (1)           // Store counter (1)

1.3 Critical Section Requirements

2. Mutex Locks

2.1 Intuition

2.2 Implementation

c
#include <pthread.h>
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
void* thread_function(void* arg) {
    pthread_mutex_lock(&lock);    // Entry section — acquire lock
    // Critical section
    shared_data++;
    pthread_mutex_unlock(&lock);  // Exit section — release lock
    return NULL;
}

2.3 Types of Mutex

2.4 Spinlock vs Mutex

3. Semaphores

3.1 Intuition

3.2 Abstract Definition

• wait(S) (P, down): Decrement S; if S < 0, block
• signal(S) (V, up): Increment S; if S ≤ 0, wake a blocked process

c
// Binary semaphore (like mutex)
sem_t sem;
sem_init(&sem, 0, 1);   // Initialize to 1
sem_wait(&sem);          // Entry section
// Critical section
sem_post(&sem);          // Exit section
// Counting semaphore — control access to N resources
sem_t pool;
sem_init(&pool, 0, N);  // N available resources
sem_wait(&pool);         // Acquire one resource
// Use resource
sem_post(&pool);         // Release resource

3.3 Binary vs Counting Semaphores

3.4 Worked Example: Producer-Consumer

c
#define BUFFER_SIZE 10
int buffer[BUFFER_SIZE];
int in = 0, out = 0;
sem_t empty;  // Counts empty slots
sem_t full;   // Counts full slots
sem_t mutex;  // Binary semaphore for mutual exclusion
void init() {
    sem_init(&empty, 0, BUFFER_SIZE);
    sem_init(&full, 0, 0);
    sem_init(&mutex, 0, 1);
}
void* producer(void* arg) {
    int item;
    while (1) {
        item = produce_item();
        sem_wait(&empty);       // Wait for empty slot
        sem_wait(&mutex);       // Lock buffer
        buffer[in] = item;
        in = (in + 1) % BUFFER_SIZE;
        sem_post(&mutex);       // Unlock buffer
        sem_post(&full);        // Signal buffer is full
    }
}
void* consumer(void* arg) {
    int item;
    while (1) {
        sem_wait(&full);        // Wait for full slot
        sem_wait(&mutex);       // Lock buffer
        item = buffer[out];
        out = (out + 1) % BUFFER_SIZE;
        sem_post(&mutex);       // Unlock buffer
        sem_post(&empty);       // Signal empty slot
        consume_item(item);
    }
}

4. Monitors

4.1 Intuition

4.2 Monitor Structure

c
#include <pthread.h>
typedef struct {
    int items;                // Shared state
    pthread_mutex_t mutex;    // For mutual exclusion
    pthread_cond_t cond;      // Condition variable
} Monitor;
void monitor_function(Monitor* m) {
    pthread_mutex_lock(&m->mutex);
    // Automatically exclusive access
    while (!condition) {
        pthread_cond_wait(&m->cond, &m->mutex);  // Release mutex, sleep
    }
    // Critical section
    pthread_cond_signal(&m->cond);  // Wake one waiting thread
    pthread_mutex_unlock(&m->mutex);
}

4.3 Condition Variables

4.4 Monitor Example: Bounded Buffer

c
#include <pthread.h>
#define N 10
int buffer[N];
int count = 0, in = 0, out = 0;
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t not_full = PTHREAD_COND_INITIALIZER;
pthread_cond_t not_empty = PTHREAD_COND_INITIALIZER;
void put(int item) {
    pthread_mutex_lock(&mutex);
    while (count == N)
        pthread_cond_wait(&not_full, &mutex);  // Wait until not full
    buffer[in] = item;
    in = (in + 1) % N;
    count++;
    pthread_cond_signal(&not_empty);  // Wake consumer
    pthread_mutex_unlock(&mutex);
}
int get() {
    pthread_mutex_lock(&mutex);
    while (count == 0)
        pthread_cond_wait(&not_empty, &mutex);  // Wait until not empty
    int item = buffer[out];
    out = (out + 1) % N;
    count--;
    pthread_cond_signal(&not_full);  // Wake producer
    pthread_mutex_unlock(&mutex);
    return item;
}

5. Common Pitfalls

Pitfall 1: Semaphore ordering in Producer-Consumer

Pitfall 2: Forgotten signal/broadcast

Pitfall 3: Spurious wakeups

c
// WRONG: spurious wakeup breaks this
if (count == 0) pthread_cond_wait(...);
// Correct: always re-check condition
while (count == 0) pthread_cond_wait(...);

6. 📐 Key Formulas / Concepts

7. 📝 Practice Questions

Q1: What is a race condition? Give an example with two threads incrementing a counter.

Answer: When two threads simultaneously execute counter++, the operation (load, increment, store) interleaves. Both read the same initial value, both increment to N+1, and both write N+1 — losing one increment. The fix is to use a mutex lock around the critical section. Q2: Explain the difference between mutex and semaphore.

Answer: A mutex is a binary lock with ownership tracking (only the locking thread can unlock). A semaphore is a signaling mechanism that can be posted by any thread. A binary semaphore can be used like a mutex but without ownership. Counting semaphores manage multiple resources. Q3: In the producer-consumer problem, why must we check the buffer condition with a while loop instead of if?

Answer: To handle spurious wakeups — pthread_cond_wait can return even without a signal. Also, after waking, another thread may have changed the condition. The while loop re-checks the condition. Q4: Write pseudocode using semaphores to solve the readers-writers problem (reader preference).

Answer:

c
sem_t resource;  // Binary semaphore for writer exclusion
sem_t rmutex;    // Protect read_count
int read_count = 0;

// Writer
wait(resource);
write();
signal(resource);

// Reader
wait(rmutex);
read_count++;
if (read_count == 1) wait(resource);
signal(rmutex);
read();
wait(rmutex);
read_count--;
if (read_count == 0) signal(resource);
signal(rmutex);

Q5: What is the difference between pthread_cond_signal and pthread_cond_broadcast?

Answer: signal wakes exactly one waiting thread (if any). broadcast wakes all waiting threads. Use signal when only one thread can proceed (e.g., a slot became available). Use broadcast when multiple threads may need to re-check their conditions (e.g., after a state change).

8. 🔗 Cross-References

• Week 6 - Deadlocks: What happens when locking goes wrong
• Week 1 - Process Management: Processes vs threads sharing data
• BSCS3005 (C Programming): pthreads library usage Join Discord PreviousCPU Scheduling: RR, Priority, MLFQNextDeadlocks