Using condition variables in pthreads

Along with mutexes, pthreads gives us another tool for synchronization between the threads, condition variables. Condition variables are variables of the kind pthread_cond_t.

When a thread is waiting on a mutex it will continuously keep polling on the mutex waiting for it to get unlocked. Such behavior could lead to wastage of CPU resources. This can be prevented by using the condition variables.

The condition variables can be initialized statically

pthread_cond_t cond_var=PTHREAD_COND_INTIALIZER

or dynamically

pthread_cond_init(<condition variable>,<attribute>).

Attribute can be left NULL if default attributes are sufficient. The only attribute condition variables have is process_shared, which indicates that the condition variable is visible to threads of other processes too.

Now to use the condition variable in a thread we have two functions

pthread_cond_wait(<condition variable>,<mutex>);

This is called when a thread wants to wait for specific task to be completed by another thread before continuing its operations. This function should be called after locking the mutex, which automatically gets unlocked once the thread goes in to wait state.

pthread_cond_signal(<condition variable>);

This function does the job of signaling to the thread that had called pthread_cond_wait. Note that the "condition variable" used in the signal and the wait functions should be the same. We need to lock the mutex that is shared by the threads before calling this function and unlock it after the call.

Once pthread_cond_signal is called the threas which was waiting on the function pthread_cond_wait will proceed with its execution.

The following program depicts the use of condition variables.
We create two threads
"fill": which fills values into an array "arr"
read: Which reads the values of the array.

Now we can read from the array unless it is not filled, thus the thread read calls pthread_cond_wait, waiting for the array to be filled. On the other hand the thread "fill" calls pthread_cond_signal once it is done filling the array.Thus making sure that the threads are in synchronization.

#include <stdio.h> #include <pthread.h> #include <stdlib.h> pthread_mutex_t fill_mutex; int arr[10]; int flag=0; pthread_cond_t cond_var=PTHREAD_COND_INITIALIZER; void *fill() { int i=0; printf("\nEnter values\n"); for(i=0;i<4;i++) { scanf("%d",&arr[i]); } pthread_mutex_lock(&fill_mutex); pthread_cond_signal(&cond_var); pthread_mutex_unlock(&fill_mutex); pthread_exit(NULL); } void *read() { int i=0; pthread_mutex_lock(&fill_mutex); pthread_cond_wait(&cond_var,&fill_mutex); pthread_mutex_unlock(&fill_mutex); printf("Values filled in array are"); for(i=0;i<4;i++) { printf("\n %d \n",arr[i]); } pthread_exit(NULL); } main() { pthread_t thread_id,thread_id1; pthread_attr_t attr; int ret; void *res; ret=pthread_create(&thread_id,NULL,&fill,NULL); ret=pthread_create(&thread_id1,NULL,&read,NULL); printf("\n Created threads"); pthread_join(thread_id,&res); pthread_join(thread_id1,&res); }

Save the program as pthread_cond.c, and compile using -lpthread flag

cc -lptread -o pthread_cond pthread_cond.c

Execute the program

$ ./pthread_cond $ Created threads Enter values 10 20 30 40 Values filled in array are 10 20 30 40

Thus we can see that the read thread was waiting until the fill thread did not call the signal, and only after receiving the signal the read thread continued execution.