CODEWITHSUNDEEP
cmultithreadingconcurrency
Shak
Shak

Reputation: 438

unexpected behavior when using conditional variables (c, gcc)

I am trying to learn how to use conditional variables properly in C. As an exercise for myself I am trying to make a small program with 2 threads that print "Ping" followed by "Pong" in an endless loop.

I have written a small program:

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;

void* T1(){
    printf("thread 1 started\n");

    while(1)
    {
        pthread_mutex_lock(&lock);
        sleep(0.5);
        printf("ping\n");
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&lock);
        pthread_cond_wait(&cond,&lock);
    }
}

void* T2(){
    printf("thread 2 started\n");

    while(1)
    {
        pthread_cond_wait(&cond,&lock);
        pthread_mutex_lock(&lock);
        sleep(0.5);
        printf("pong\n");
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&lock);
    }
}

int main(void)
{
    int i = 1;
    pthread_t t1;
    pthread_t t2;



    printf("main\n");
    pthread_create(&t1,NULL,&T1,NULL);
    pthread_create(&t2,NULL,&T2,NULL);
    while(1){
        sleep(1);
        i++;
    }
    return EXIT_SUCCESS;
}

And when running this program the output I get is:

main
thread 1 started
thread 2 started
ping

Any idea what is the reason the program does not execute as expected?

Thanks in advance.

Upvotes: 0

Views: 99

Answers (2)

simo-r
simo-r

Reputation: 733

First of all you should never use sleep() to synchronize threads (use nanosleep() if you need to reduce output speed). You may need (it's a common use) a shared variable ready to let each thread know that he can print the message. Before you make a pthread_cond_wait() you must acquire the lock because the pthread_cond_wait() function shall block on a condition variable. It shall be called with mutex locked by the calling thread or undefined behavior results.

Steps are:

  1. Acquire the lock
  2. Use wait in a while with a shared variable in guard[*]
  3. Do stuffs
  4. Change the value of shared variable for synchronize (if you've one) and signal/broadcast that you finished to work
  5. Release the lock

Steps 4 and 5 can be reversed.

[*]You use pthread_cond_wait() to release the mutex and block the thread on the condition variable and when using condition variables there is always a Boolean predicate involving shared variables associated with each condition wait that is true if the thread should proceed because spurious wakeups may occur. watch more here

pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
int ready = 0;
void* T1(){
    printf("thread 1 started\n");

    while(1)
    {
        pthread_mutex_lock(&lock);
        while(ready == 1){
            pthread_cond_wait(&cond,&lock);
        }
        printf("ping\n");
        ready = 1;
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&lock);
    }
}

void* T2(){
    printf("thread 2 started\n");

    while(1)
    {
        pthread_mutex_lock(&lock);
        while(ready == 0){
            pthread_cond_wait(&cond,&lock);
        }
        printf("pong\n");
        ready = 0;
        pthread_cond_signal(&cond);
        pthread_mutex_unlock(&lock);
    }
}

int main(void)
{
    int i = 1;
    pthread_t t1;
    pthread_t t2;



    printf("main\n");
    pthread_create(&t1,NULL,&T1,NULL);
    pthread_create(&t2,NULL,&T2,NULL);
    pthread_join(t1,NULL);
    pthread_join(t2,NULL);
    return EXIT_SUCCESS;
}

You should also use pthread_join() in main instead of a while(1)

Upvotes: 1

Art
Art

Reputation: 20392

sleep takes an integer, not a floating point. Not sure what sleep(0) does on your system, but it might be one of your problems.

You need to hold the mutex while calling pthread_cond_wait.

Naked condition variables (that is condition variables that don't indicate that there is a condition to read somewhere else) are almost always wrong. A condition variable indicates that something we are waiting for might be ready to be consumed, they are not for signalling (not because it's illegal, but because it's pretty hard to get them right for pure signalling). So in general a condition will look like this:

 /* consumer here */
 pthread_mutex_lock(&something_mutex);
 while (something == 0) {
     pthread_cond_wait(&something_cond, &something_mutex);
 }
 consume(something);
 pthread_mutex_unlock(&something_mutex);

 /* ... */

 /* producer here. */
 pthread_mutex_lock(&something_mutex);
 something = 4711;
 pthread_cond_signal(&something_cond, &something_mutex);
 pthread_mutex_unlock(&something_mutex);

It's a bad idea to sleep while holding locks.

T1 and T2 are not valid functions to use as functions to pthread_create they are supposed to take arguments. Do it right.

You are racing yourself in each thread between cond_signal and cond_wait, so it's not implausible that each thread might just signal itself all the time. (correctly holding the mutex in the calls to pthread_cond_wait may help here, or it may not, that's why I said that getting naked condition variables right is hard, because it is).

Upvotes: 2

Related Questions