Condition Variables for Synchronization

• As it is noted in the previous section, indiscriminate use of locks can result in idling overhead from blocked threads. While the function pthread_mutex_trylock alleviates this overhead, it introduces the overhead of polling for availability of locks.
• For example, if the producer-consumer example is rewritten using pthread_mutex_trylock instead of pthread_mutex_lock, the producer and consumer threads would have to periodically poll for availability of lock (and subsequently availability of buffer space or tasks on queue).
• A natural solution to this problem is to suspend the execution of the producer until space becomes available (an interrupt driven mechanism as opposed to a polled mechanism).
• The availability of space is signaled by the consumer thread that consumes the task. The functionality to accomplish this is provided by a condition variable.
• A condition variable is a data object used for synchronizing threads. This variable allows a thread to block itself until specified data reaches a predefined state.
• In the producer-consumer case, the shared variable task_available must become 1 before the consumer threads can be signaled.
• The boolean condition task_available == 1 is referred to as a predicate. A condition variable is associated with this predicate.
• When the predicate becomes true, the condition variable is used to signal one or more threads waiting on the condition.
• A single condition variable may be associated with more than one predicate. However, this is strongly discouraged since it makes the program difficult to debug.
• A condition variable always has a mutex associated with it. A thread locks this mutex and tests the predicate defined on the shared variable (in this case: task_available); if the predicate is not true, the thread waits on the condition variable associated with the predicate using the function pthread_cond_wait.

  1   int pthread_cond_wait(pthread_cond_t *cond, 
  2       pthread_mutex_t *mutex);
  

• A call to this function blocks the execution of the thread until it receives a signal from another thread or is interrupted by an OS signal.
• In addition to blocking the thread, the pthread_cond_wait function releases the lock on mutex. This is important because otherwise no other thread will be able to work on the shared variable task_available and the predicate would never be satisfied.
• When the thread is released on a signal, it waits to reacquire the lock on mutex before resuming execution.
• It is convenient to think of each condition variable as being associated with a queue. Threads performing a condition wait on the variable relinquish their lock and enter the queue.
• When the condition is signaled (using pthread_cond_signal), one of these threads in the queue is unblocked, and when the mutex becomes available, it is handed to this thread (and the thread becomes runnable).
• In the context of our producer-consumer example, the producer thread produces the task and, since the lock on mutex has been relinquished (by waiting consumers), it can insert its task on the queue and set task_available to 1 after locking mutex. Since the predicate has now been satisfied, the producer must wake up one of the consumer threads by signaling it.

  1       int pthread_cond_signal(pthread_cond_t *cond);
  

• The function unblocks at least one thread that is currently waiting on the condition variable cond. The producer then relinquishes its lock on mutex by explicitly calling pthread_mutex_unlock, allowing one of the blocked consumer threads to consume the task.
• Before our producer-consumer example is rewriten using condition variables, we need to introduce two more function calls for initializing and destroying condition variables, pthread_cond_init and pthread_cond_destroy; respectively.

  1   int pthread_cond_init(pthread_cond_t *cond, 
  2       const pthread_condattr_t *attr); 
  3   int pthread_cond_destroy(pthread_cond_t *cond);
  

• The function pthread_cond_init initializes a condition variable (pointed to by cond) whose attributes are defined in the attribute object attr. Setting this pointer to NULL assigns default attributes for condition variables.
• If at some point in a program a condition variable is no longer required, it can be discarded using the function pthread_cond_destroy.
• These functions for manipulating condition variables enable us to rewrite our producer-consumer segment.
• Producer-consumer using condition variables
  • Condition variables can be used to block execution of the producer thread when the work queue is full and the consumer thread when the work queue is empty.
  • We use two condition variables cond_queue_empty and cond_queue_full for specifying empty and full queues respectively.
  • The predicate associated with cond_queue_empty is task_available == 0, and cond_queue_full is asserted when task_available == 1.
  • The producer queue locks the mutex task_queue_cond_lock associated with the shared variable task_available.
  • It checks to see if task_available is 0 (i.e., queue is empty). If this is the case, the producer inserts the task into the work queue and signals any waiting consumer threads to wake up by signaling the condition variable cond_queue_full. It subsequently proceeds to create additional tasks.
  • If task_available is 1 (i.e., queue is full), the producer performs a condition wait on the condition variable cond_queue_empty (i.e., it waits for the queue to become empty).
  • The reason for implicitly releasing the lock on task_queue_cond_lock becomes clear at this point. If the lock is not released, no consumer will be able to consume the task and the queue would never be empty. At this point, the producer thread is blocked.
  • Since the lock is available to the consumer, the thread can consume the task and signal the condition variable cond_queue_empty when the task has been taken off the work queue.
  • The consumer thread locks the mutex task_queue_cond_lock to check if the shared variable task_available is 1. If not, it performs a condition wait on cond_queue_full. (Note that this signal is generated from the producer when a task is inserted into the work queue.)
  • If there is a task available, the consumer takes it off the work queue and signals the producer. In this way, the producer and consumer threads operate by signaling each other. It is easy to see that this mode of operation is similar to an interrupt-based operation as opposed to a polling-based operation of pthread_mutex_trylock.

    1   pthread_cond_t cond_queue_empty, cond_queue_full; 
    2   pthread_mutex_t task_queue_cond_lock; 
    3   int task_available; 
    4 
    5   /* other data structures here */ 
    6 
    7   main() { 
    8       /* declarations and initializations */ 
    9       task_available = 0; 
    10      pthread_init(); 
    11      pthread_cond_init(&cond_queue_empty, NULL); 
    12      pthread_cond_init(&cond_queue_full, NULL); 
    13      pthread_mutex_init(&task_queue_cond_lock, NULL); 
    14      /* create and join producer and consumer threads */ 
    15  } 
    16 
    17  void *producer(void *producer_thread_data) { 
    18      int inserted; 
    19      while (!done()) { 
    20          create_task(); 
    21          pthread_mutex_lock(&task_queue_cond_lock); 
    22          while (task_available == 1) 
    23              pthread_cond_wait(&cond_queue_empty, 
    24                  &task_queue_cond_lock); 
    25          insert_into_queue(); 
    26          task_available = 1; 
    27          pthread_cond_signal(&cond_queue_full); 
    28          pthread_mutex_unlock(&task_queue_cond_lock); 
    29      } 
    30  } 
    31 
    32  void *consumer(void *consumer_thread_data) { 
    33      while (!done()) { 
    34          pthread_mutex_lock(&task_queue_cond_lock); 
    35          while (task_available == 0) 
    36              pthread_cond_wait(&cond_queue_full, 
    37                  &task_queue_cond_lock); 
    38          my_task = extract_from_queue(); 
    39          task_available = 0; 
    40          pthread_cond_signal(&cond_queue_empty); 
    41          pthread_mutex_unlock(&task_queue_cond_lock); 
    42          process_task(my_task); 
    43      } 
    44  }
    

  • An important point to note about this program segment is that the predicate associated with a condition variable is checked in a loop.
  • One might expect that when cond_queue_full is asserted, the value of task_available must be 1. However, it is a good practice to check for the condition in a loop because the thread might be woken up due to other reasons (such as an OS signal).
  • In other cases, when the condition variable is signaled using a condition broadcast (signaling all waiting threads instead of just one), one of the threads that got the lock earlier might invalidate the condition.
  • In the example of multiple producers and multiple consumers, a task available on the work queue might be consumed by one of the other consumers.
  • When a thread performs a condition wait, it takes itself off the runnable list consequently, it does not use any CPU cycles until it is woken up. This is in contrast to a mutex lock which consumes CPU cycles as it polls for the lock.
  • In the above example, each task could be consumed by only one consumer thread. Therefore, we choose to signal one blocked thread at a time.
  • In some other computations, it may be beneficial to wake all threads that are waiting on the condition variable as opposed to a single thread. This can be done using the function pthread_cond_broadcast.

    1   int pthread_cond_broadcast(pthread_cond_t *cond);
    

  • An example of this is in the producer-consumer scenario with large work queues and multiple tasks being inserted into the work queue on each insertion cycle. Another example of the use of pthread_cond_broadcast is in the implementation of barriers.
  • It is often useful to build time-outs into condition waits. Using the function pthread_cond_timedwait, a thread can perform a wait on a condition variable until a specified time expires. At this point, the thread wakes up by itself if it does not receive a signal or a broadcast.

    1   int pthread_cond_timedwait(pthread_cond_t *cond, 
    2       pthread_mutex_t *mutex, 
    3       const struct timespec *abstime);
    

    If the absolute time abstime specified expires before a signal or broadcast is received, the function returns an error message. It also reacquires the lock on mutex when it becomes available.