Scheduling of Multiple Threads using Mutex and Condition Variable - c

Question

I'm trying to create four threads printing some message.
I'm facing some issue with synchronisation.
Here is what my main() looks like
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int count = 4;
int main (void)
{
pthread_t thread1, thread2, thread3, thread4;
pthread_create (&thread4, NULL, function4, NULL);
pthread_create (&thread3, NULL, function3, NULL);
pthread_create (&thread2, NULL, function2, NULL);
pthread_create (&thread1, NULL, function1, NULL);
pthread_join (thread1, NULL);
pthread_join (thread2, NULL);
pthread_join (thread3, NULL);
pthread_join (thread4, NULL);
return 0;
}
function1() prints Function 1, function2() prints Function 2 and so on.
Desired Output should be the following:
Function 1
Function 2
Function 3
Function 4
Actual Output:
Function 1
/* Infinitely runs (Deadlock maybe) */
Actual Question:
Can we use one single condition variable for Synchronization of two or more threads ? If so how ?
If not, how do I tackle this problem ?
Here is the definition of function(n)
void *function1 ()
{
while (1)
{
if (count == 4)
{
pthread_mutex_lock (&mutex);
printf("Function 1\n");
count --;
pthread_mutex_unlock (&mutex);
pthread_cond_signal (&cond);
return NULL;
}
else
pthread_cond_wait(&cond, &mutex);
}
return NULL;
}
void *function2 ()
{
while (1)
{
if (count == 3)
{
pthread_mutex_lock (&mutex);
printf("Function 2\n");
count--;
pthread_mutex_unlock (&mutex);
pthread_cond_signal (&cond);
return NULL;
}
else
pthread_cond_wait(&cond, &mutex);
}
return NULL;
}
void *function3 ()
{
while (1)
{
if(count == 2)
{
pthread_mutex_lock (&mutex);
printf("Function 3\n");
count--;
pthread_mutex_unlock (&mutex);
pthread_cond_signal (&cond);
return NULL;
}
else
pthread_cond_wait(&cond, &mutex);
}
return NULL;
}
void *function4 ()
{
while (1)
{
if(count == 1)
{
pthread_mutex_lock (&mutex);
printf("Function 4\n");
pthread_mutex_unlock (&mutex);
pthread_cond_signal (&cond);
return NULL;
}
else
pthread_cond_wait(&cond, &mutex);
}
return NULL;
}

Answer 1

After a more clear understanding, I have resolved this issue.
This is a case of race condition.
Things wrong with the code:
Use pthread_cond_broadcast instead ofpthread_cond_signal.
From the man pages
The pthread_cond_broadcast() function shall unblock all threads currently blocked on the specified condition variable cond.
The pthread_cond_signal() function shall unblock at least one of the threads that are blocked on the specified condition variable cond
Not acquiring a lock before checking for if (count == X), Need a
place a lock before that (since count is global/shared variable).
Not placing an unlock if the control goes to else. Since a lock
is already placed (earlier before else), you need to unlock
it.
If you fail to do so, other threads will try to lock a mutex,
that is already locked , leading to race conditions.
Function should be as follow
void *function1 ()
{
while (1)
{
/* Take a lock on the Mutex */
pthread_mutex_lock (&mutex);
if (4 == count)
{
printf("Function 1\n"); /* Perform your task */
count--;
/* Once operation on shared variable (count) is completed, release lock*/
pthread_mutex_unlock (&mutex);
/* Broadcast to other threads about completion of task */
pthread_cond_broadcast (&cond);
return NULL;
}
else
{
/* If count doesnt match, wait on the condition (wait for signal from other threads) */
pthread_cond_wait(&cond, &mutex);
/* Unlock the mutex, since it was locked earlier - else goes to deadlock */
pthread_mutex_unlock (&mutex);
}
}
return NULL;
}
Here is the complete working code.

Answer 2

The change required is simple:
instead of:
else
pthread_cond_wait(&cond, &mutex);
do this:
else {
pthread_mutex_lock (&mutex);
pthread_cond_wait(&cond, &mutex);
pthread_mutex_unlock (&mutex);
}
It works for me with these changes, but results in unpredictable behaviour without the changes.
Edit:
This above mentioned simple way still leaves a race condition and doesn't fix the signal vs broadcast problem. To avoid it, the code should be structured like the following:
pthread_mutex_lock (&mutex);
if (count == 4)
{
printf("Function 1\n");
count --;
pthread_mutex_unlock (&mutex);
pthread_cond_broadcast (&cond); // NOTE: broadcast, not signal!
return NULL;
}
else
pthread_cond_wait(&cond, &mutex);
pthread_mutex_unlock (&mutex);
Note that pthread_cond_broadcast is necessary as you want to wake up all threads.