printing odd and even number using threads - c

Question

I know there are many examples for my question. However, I want to understand why 1 program that I wrote works and other doesn't.
Here is what I have written.
void * even()
{
while(1)
{
pthread_mutex_lock(&lock);
if(count % 2 == 0)
{
printf("count %d\n",count);
pthread_cond_signal(&cond);
}
else
{
pthread_cond_wait(&cond,&lock);
}
count++;
pthread_mutex_unlock(&lock);
if(count >= 100) return NULL;
}
}
void * odd()
{
while(1)
{
pthread_mutex_lock(&lock);
if(count % 2 == 1)
{
printf("count %d\n",count);
pthread_cond_signal(&cond);
}
else
{
pthread_cond_wait(&cond,&lock);
}
count++;
pthread_mutex_unlock(&lock);
if(count >= 100) return NULL;
}
}
So the above piece of code prints only 0 or 0 and 1 sometimes. However the below code works fine.
void * even()
{
while(1)
{
pthread_mutex_lock(&lock);
if(count % 2 == 0)
{
printf("count %d\n",count);
count++;
pthread_cond_signal(&cond);
}
else
{
pthread_cond_wait(&cond,&lock);
}
pthread_mutex_unlock(&lock);
if(count >= 100) return NULL;
}
}
void * odd()
{
while(1)
{
pthread_mutex_lock(&lock);
if(count % 2 == 1)
{
printf("count %d\n",count);
count++;
pthread_cond_signal(&cond);
}
else
{
pthread_cond_wait(&cond,&lock);
}
pthread_mutex_unlock(&lock);
if(count >= 100) return NULL;
}
}
Thanks a lot.

Answer 1

In the first example, some variation of the below may happen:
even() acquires the lock
even() prints count (which is 0) and signals the condition (though odd() can't wake until even() releases the lock)
even() increments count to 1
even() releases the lock, and odd() wakes.
odd() increments count to 2
odd() releases the lock (but hasn't signalled the condition)
odd() acquires the lock
odd() waits, because count is even (== 2)... now both threads are waiting and neither can signal the condition.
Things may happen slightly differently depending on which thread goes first, but both threads still get stuck in a way similar to the above.
Both examples are unreliable, though, because they don't account for spurious wakeups when waiting for the condition. Normally a loop should be used to retry the wait if the desired wakeup conditions aren't met, holding the lock the whole time so a signal won't be missed:
pthread_mutex_lock(&lock);
/* ...stuff... */
/* Use a loop to restart the wait if it was interrupted early */
while(count % 2 != 0)
pthread_cond_wait(&cond,&lock);
/* ...stuff... */
pthread_mutex_unlock(&lock);

Answer 2

In the first example, in even(), then if count is odd, you pthread_cond_signal odd() to run if count is even. count will be incremented, and the mutex dropped. At this point odd() may run and signal even() before even() ever reaches the pthread_cond_wait(). Now odd() will never again signal even() (because count is now even), and the even()'s pthread_cond_wait() will never exit.
But both of your examples are buggy. You are (last full line) reading count outside the mutex that protects it.

Answer 3

#include <stdio.h>
#include <pthread.h>
#include<iostream>
void *odd(void* data);
void *even(void* data);
static int count=0;
pthread_mutex_t mutex;
pthread_cond_t cond;
int main()
{
pthread_t thread1,thread2;
pthread_create(&thread1,NULL,&even,0);
pthread_create(&thread2,NULL,&odd,0);
pthread_join(thread1,NULL);
pthread_join(thread2,NULL);
return 0;
}
void *even(void* data)
{
pthread_mutex_lock(&mutex);
while(count< 10)
{
while(count%2!=0)
{
pthread_cond_wait(&cond,&mutex);
}
std::cout<<count;
count++;
pthread_mutex_unlock(&mutex);
pthread_cond_signal(&cond);
}
pthread_exit(0);
}
void *odd(void* data)
{
pthread_mutex_lock(&mutex);
while(count<10)
{
while(count%2!=1)
{
pthread_cond_wait(&cond,&mutex);
}
std::cout<<count;
count++;
pthread_mutex_unlock(&mutex);
pthread_cond_signal(&cond);
}
pthread_exit(0);
}