Pthreads and signals C++ - c++

Question

I'm new to threads and seem to be having a timing problem. When I run my code my output is...
Data received!
Data processed!
and then it just hangs. I assume I'm using wait and signal incorrectly. Help would be greatly appreciated.
#include <string.h>
#include <pthread.h>
#include <stdio.h>
#include <unistd.h>
char buffer [100];
pthread_mutex_t buffer_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t buffer_cond = PTHREAD_COND_INITIALIZER;
void* threadFunc(void *proc){
if((int)proc == 0){
pthread_mutex_lock(&buffer_mutex);
sprintf(buffer, "Data received!\n");
printf("%s", buffer);
pthread_cond_signal(&buffer_cond);
pthread_mutex_unlock(&buffer_mutex);
}
else if((int)proc == 1){
pthread_mutex_lock(&buffer_mutex);
pthread_cond_wait(&buffer_cond, &buffer_mutex);
sprintf(buffer, "Data processed!\n");
printf("%s", buffer);
pthread_cond_signal(&buffer_cond);
pthread_mutex_unlock(&buffer_mutex);
}
else{
sleep(1);
pthread_mutex_lock(&buffer_mutex);
pthread_cond_wait(&buffer_cond, &buffer_mutex);
sprintf(buffer, "Data sent!\n");
printf("%s", buffer);
pthread_mutex_unlock(&buffer_mutex);
}
return(NULL);
}
int main()
{
pthread_t threads[3];
for(int i = 0; i < 3; i++){
pthread_create(&threads[i], NULL, threadFunc, (void *) i);
}
for(int i = 0; i < 3; i++){
pthread_join(threads[i], NULL);
}
return 0;
}

Answer 1

A condition variable is near-useless without a predicate, a conditional state that dictates what has changed. The condition variable is little more than a signaling mechanism to announce that "something" may have changed, but you still need to manage the "what". And that mutex is what protects that "what".
For example:
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <pthread.h>
char buffer [100];
int state = 0;
pthread_mutex_t buffer_mutex = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t buffer_cond = PTHREAD_COND_INITIALIZER;
void* threadFunc(void *proc)
{
intptr_t iptr = (intptr_t)proc;
pthread_mutex_lock(&buffer_mutex);
switch(iptr)
{
case 0:
{
while (state != 1) // 1 means data available
pthread_cond_wait(&buffer_cond, &buffer_mutex);
// mutex is locked. access predicate data
printf("Data received: %s\n", buffer);
state = 2; // advance state
pthread_mutex_unlock(&buffer_mutex);
pthread_cond_broadcast(&buffer_cond);
}
break;
case 1:
{
while (state != 2)
pthread_cond_wait(&buffer_cond, &buffer_mutex);
// mutex is locked. access predicate data
printf("Data processed: %s\n", buffer);
pthread_mutex_unlock(&buffer_mutex);
}
break;
default:
{
// setup initial send-state
printf("Data sent: %s\n", buffer);
state = 1;
pthread_mutex_unlock(&buffer_mutex);
pthread_cond_broadcast(&buffer_cond);
}
}
return NULL;
}
int main()
{
pthread_t threads[3];
intptr_t i = 0;
strcpy(buffer, "Some message");
for(i = 0; i < 3; i++){
pthread_create(&threads[i], NULL, threadFunc, (void *) i);
}
for( i = 0; i < 3; i++)
pthread_join(threads[i], NULL);
return 0;
}
Output
Data sent: Some message
Data received: Some message
Data processed: Some message
This simply starts up three threads. One (id=0) will wait for the state to become 1, then proceed with its job of announcing what happened, advancing the state, and signaling the condition. The second (id=1) waits for that state, does its job similarly, then simply exits as there is nothing else to to. The third (id=2) is the one that kicks off the process, then silently finishes.
Note that at no time is the predicate data (the state) changed or checked without being under the protection of the mutex on whatever thread is doing said check/changing.
Three timelines with mutex-latch state and which thread owns it will speak volumes in understanding how this works, and I highly advise you get a pencil and paper to assist on that regard.
Best of luck.