Thread Synchronization in Operating Systems: Condition Variables

I. Problem Description
A condition variable is a crucial mechanism for thread synchronization in operating systems, used to address scenarios where threads need to wait for a specific condition to become true. When a condition is not met, a thread can actively wait on that condition variable; when another thread changes the condition and makes it true, it can wake up the waiting thread(s) to resume execution. It is typically used in conjunction with a mutex (mutual exclusion lock) to ensure that checking and modifying the shared condition are atomic operations.

II. Core Concept Analysis

1. Why are condition variables needed?

   • A mutex only solves mutual exclusion for critical sections but cannot address the "waiting for a condition to become true" problem.
   • Example: A consumer thread needs to wait for a queue to be non-empty before it can consume. Using only a mutex would lead to busy-waiting (repeatedly looping to check), wasting CPU resources.

2. Core operations of condition variables

   • wait(lock): Releases the lock and enters a waiting state; re-acquires the lock upon being woken up.
   • signal() / notify(): Wakes up one waiting thread.
   • broadcast() / notify_all(): Wakes up all waiting threads.

III. Standard Usage Pattern for Condition Variables
Taking the producer-consumer problem as an example (simplified version with a single condition variable):

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
Queue buffer;  // Shared buffer

// Producer thread
void producer() {
    pthread_mutex_lock(&lock);
    // Produce data and put it into the buffer
    buffer.push(item);
    // Notify the consumer
    pthread_cond_signal(&cond);
    pthread_mutex_unlock(&lock);
}

// Consumer thread
void consumer() {
    pthread_mutex_lock(&lock);
    while (buffer.empty()) {  // Must use a while loop to check
        pthread_cond_wait(&cond, &lock);  // Atomic operation: release lock + wait
    }
    // Consume data
    item = buffer.pop();
    pthread_mutex_unlock(&lock);
}

IV. Key Details and Principle Analysis

1. Why does wait() need to be paired with a mutex?

   • To ensure that checking the condition (e.g., buffer.empty()) and entering the wait state are atomic operations.
   • To prevent this race condition: The consumer checks the condition and finds it true → prepares to wait, but the producer modifies the condition and sends a signal (the consumer hasn't started waiting yet, so the signal is lost).

2. Why use a while loop instead of an if statement to check the condition?

   • Spurious wakeups: Some systems may wake threads up without reason (e.g., due to signal interrupts, or when multiple consumers exist and another consumer grabs the resource).
   • Broadcast wakeups: After being woken by broadcast(), threads need to re-check the condition.
   • Therefore, upon being woken, a thread must always re-verify whether the condition is truly satisfied.

3. Atomicity principle of the wait() operation

   • Step 1: Release the mutex (allowing other threads to modify the condition).
   • Step 2: The thread enters the waiting queue and blocks.
   • Step 3: Upon being woken, re-acquire the mutex.
   • These three steps are an atomic operation, preventing signal loss.

V. Practical Application Scenarios for Condition Variables

1. Thread pool task scheduling: Worker threads wait for the task queue to be non-empty.
2. Read-write lock implementation: Writer threads wait for all reader threads to finish.
3. Barrier synchronization: Multiple threads wait for each other to reach a synchronization point.
4. Finite state machines: Threads wait for state transitions.

VI. Common Errors and Best Practices

1. Error example: Checking the condition without holding the lock (race condition).
2. Error example: Using if instead of while to check the condition (spurious wakeup problem).
3. Best practice: Always follow the "lock → while (check condition) → wait → unlock" pattern.
4. Signaling timing: Send the signal after modifying the condition, typically within the critical section (while holding the lock).

Through the correct use of condition variables, efficient thread synchronization can be achieved, avoiding CPU waste caused by busy-waiting. They are fundamental tools for building high-performance concurrent programs.