Why does pthread_cond_signal sometimes not work? - c

Question

My program performs "thread synchronization" using pthread_cond_wait and pthread_cond_signal. It seems to fail about one in 20 times.
I have a shared variable count which is initialized to 0.
One thread increments count until count is 20 , then signals a condition variable.
The code is below.
void* inc_count(void *parm)
{
int i;
for(i = 0 ; i <25; i ++)// adds count to 25
{
pthread_mutex_lock(&mutex1);
count ++;
printf("Thread %lld , count = %d\n",(long long int)pthread_self(),count);
if(count == 20)
{
pthread_cond_signal(&cond);
printf("Thread %lld sends a signal!\n",(long long int)pthread_self());
}
pthread_mutex_unlock(&mutex1);
}
pthread_exit(NULL);
}
void* watch_count(void *parm)
{
while(count < 20)
{
pthread_mutex_lock(&mutex1);
pthread_cond_wait(&cond,&mutex1);
printf("Thread %lld receives the signal!\n",(long long int)pthread_self());
}
pthread_mutex_unlock(&mutex1);
pthread_exit(NULL);
}
int main()
{
pthread_t pt1,pt2,pt3,pt4;
pthread_mutex_init(&mutex1,NULL);
pthread_mutex_init(&mutex2,NULL);
pthread_cond_init(&cond,NULL);
pthread_create(&pt1,NULL,inc_count,NULL);
pthread_create(&pt2,NULL,watch_count,NULL);
pthread_join(pt1,NULL);
pthread_join(pt2,NULL);
}
From the picture, you can see that thread pt2 didn't receive the signal, why?

Answer 1

Your watch_count() function has problems:
You're locking the mutex inside a while loop and only unlocking outside it (could try to lock more than once without unlocking)
You don't hold the mutex when checking count < 20
To fix it, you need lock the mutex before the loop instead of inside it:
pthread_mutex_lock(&mutex1);
while(count < 20)
{
pthread_cond_wait(&cond,&mutex1);
printf("Thread %lld receives the signal!\n",(long long int)pthread_self());
}
pthread_mutex_unlock(&mutex1);
That will keep you from locking the mutex more than once before unlocking, and ensure that count can't be modified and the signal can't be sent between the test in the while condition and the pthread_cond_wait (inc_count()'s change to count and sending the signal would have to occur either before the while loop, or during the pthread_cond_wait()).
Even with those changes, there's still the possibility that the wait won't happen at all if count is already 20 by the time watch_count() checks it, though.

Answer 2

#Dmitri's diagnosis at the end of his comment is the likely cultprit IMO: it's possible that your inc_count thread gets past 20 before the watch_count thread first checks the while condition.
Why use the while loop at all? When inc_count sends the signal, you already know that the count is over 20, so why check for it?
My solution is to do some handshaking and make sure that watch_count enters its wait condition before inc_count starts counting. To achieve this, you need to make sure that the following things happen in order:
inc_count enters its code first and then waits for watch_count to initialize
watch_count enters its code and signals inc_count that it's ready to go
watch_count waits for inc_count to signal it
inc_count starts counting and signals watch_count when it gets to 20
I achieved this by grabbing a mutex before starting either thread, then counting on the first thread to enter its "ready and waiting" condition before starting the second thread. When the second thread is ready it signals the first thread to go ahead and start counting, here's my code:
void* inc_count(void *parm)
{
// holding this mutex on entry;
pthread_mutex_t* m = parm;
int i;
// wait for the watch_count thread to be ready
pthread_cond_wait(&init_cond, m);
pthread_mutex_unlock(m);
// start counting
for(i = 0 ; i < 10000; i ++)
{
pthread_mutex_lock(&count_mutex);
count++;
printf("Thread %lld , count = %d\n",
(long long int) pthread_self(),
count);
if(count == 20)
{
pthread_cond_signal(&count_cond);
printf("Thread %lld sends a signal!\n",
(long long int)pthread_self());
}
pthread_mutex_unlock(&count_mutex);
}
pthread_exit(NULL);
}
void* watch_count(void *parm)
{
// holding this mutex on entry
pthread_mutex_t* m = parm;
pthread_cond_signal(&init_cond); // tell inc_count that you're ready
pthread_cond_wait(&count_cond,m); // wait for him to get to 20
pthread_mutex_unlock(m);
pthread_mutex_lock(&count_mutex);
printf("Thread %lld receives the signal! count == %d\n",
(long long int)pthread_self(),
count);
pthread_mutex_unlock(&count_mutex);
pthread_exit(NULL);
}
int main()
{
pthread_t pt1,pt2;
pthread_mutex_t init_mutex, count_mutex;
pthread_mutex_init(&init_mutex,NULL);
pthread_mutex_init(&count_mutex,NULL);
pthread_cond_init(&init_cond,NULL);
pthread_cond_init(&count_cond,NULL);
// this mutex is released when inc_count has initialized
pthread_mutex_lock(&init_mutex);
pthread_create(&pt1,NULL,inc_count,(void *) &init_mutex);
// this mutex is released when watch-count has initialized
pthread_mutex_lock(&init_mutex);
pthread_create(&pt2,NULL,watch_count,(void *) &init_mutex);
pthread_join(pt1,NULL);
pthread_join(pt2,NULL);
}