Single producer and multiple consumers - c

Question

I am trying to work with a scenario where a producer produces a value into the buffer (state.value) and multiple consumers are reading the buffer and updating it in the array. Below is the code.
#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
pthread_mutex_t mutex;
pthread_cond_t prod, cons;
static int count = 0;
struct shared_state{
int done;
int value;
int value_available;
int *array;
int j;
}state;
void * producer(void *arg){
int a[] = {12,11,10,9,8,7};
int size = sizeof(a)/sizeof(a[0]);
int i = 0;
while(i<size){
pthread_mutex_lock(&mutex);
while(state.value_available)
pthread_cond_wait(&prod, &mutex);
state.value = a[i++];
printf("In producer: %d\n",state.value);
state.value_available = 1;
pthread_cond_signal(&cons);
pthread_mutex_unlock(&mutex);
}
state.done = 1;
count++;
printf("Producer count: %d\n",count);
pthread_exit(NULL);
}
void * consumer(void *arg){
while(!(state.done)){
pthread_mutex_lock(&mutex);
while(!state.value_available)
pthread_cond_wait(&cons,&mutex);
state.array[(state.j)] = state.value;
printf("In consumer: %d\t%d\n",state.array[state.j], state.j);
(state.j)++;
state.value_available = 0;
pthread_cond_signal(&prod);
pthread_mutex_unlock(&mutex);
}
int i;
for(i=0;i<6;i++)
printf("%d-->",state.array[i]);
printf("\n");
count++;
printf("Consumer count: %d\n",count);
}
int main(void){
state.done = 0;
pthread_t pro,con,con2;
state.value_available = 0;
state.j = 0;
state.array = (int *)malloc(sizeof(int)*6);
pthread_create(&pro, NULL, producer, (void *)NULL);
pthread_create(&con, NULL, consumer, (void *)NULL);
pthread_create(&con2, NULL, consumer, (void *)NULL);
pthread_join(pro,NULL);
pthread_join(con,NULL);
pthread_join(con2,NULL);
pthread_exit(NULL);
printf("\n");
return 0;
}
Below is the output I am receiving. However, the second consumer thread doesn't exit and runs into an infinite loop. It'll be helpful if someone could help me in identifying the error. Thanks.
In producer: 12
In consumer: 12
In producer: 11
In consumer: 11
In producer: 10
In consumer: 10
In producer: 9
In consumer: 9
In producer: 8
In consumer: 8
In producer: 7
Producer count: 1
In consumer: 7
Consumer array: 12-->11-->10-->9-->8-->7-->
Consumer count: 2

Answer 1

In the first place, you fail to initialize your mutex and your condition variables. Because they are globals, their initial state is not for that reason indeterminate, but neither is it necessarily valid. You must either use the appropriate initialization functions or initialize with the for-purpose initialization macros. For example,
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t prod = PTHREAD_COND_INITIALIZER;
pthread_cond_t cons = PTHREAD_COND_INITIALIZER;
You appear to be lucking out on that issue, but that does not mean you shouldn't fix it.
In the second place, you do not check the return values of your function calls for error codes. You really must do that for your code to be robust. Errors happen both because of broken code and because of uncontrolled runtime issues, and if you assume that your function calls will always succeed then you will come to grief sooner or later.
You have a bigger problem, however: pthread_cond_signal() wakes one thread waiting on the given condition variable, if indeed any are waiting. It is likely that both consumer threads will be blocked on the condition when the producer signals the CV for the last time. In that case, one wakes and performs its processing, but the other remains blocked. Because the consumers perform a proper check on the condition predicate after waking from their wait, you can solve that problem by using pthread_cond_broadcast() instead.
But that's only half a solution. Because you indeed do perform a proper predicate check, and because the consumer will update the shared state so that its own predicate is false before it releases the mutex, the second consumer would just resume waiting anyway if it did wake from the wait. Besides, what would it do if it did not resume waiting? There is no value available for it to consume, and no alternative path for it to take.
Bottom line:
Your producer must broadcast to the consumers' CV instead of signaling to it, at least after producing its last item.
When the consumer wakes from waiting on the CV, it must check not only whether a value is available, but also whether the producer is done. It must not resume waiting under either circumstance, but it must consume a value only if one is actually available.