Why does pthread_cond_signal not work?【转】

时间：2021-08-14 20:20:10

转自：http://*.com/questions/16819169/why-does-pthread-cond-signal-not-work#

0 down vote favorite

 

I am currently learing all around POSIX threads (pthread).

I now have created a simple program which increased a shared value by 7 until above 10000 then it should signal a condition to the next thread which decreases it by 3 until under 1000. At last it should divide the result through 2 and main should output the result.

my code

pthread_t threads[];

pthread_cond_t cond_a, cond_b;

pthread_mutex_t mutex;

int counter;

void * worker_one();

void * worker_two();

void * worker_three();

int main(int argv, const char ** argc) {

    counter = ;

    pthread_cond_init(&cond_a, NULL);

    pthread_cond_init(&cond_b, NULL);

    pthread_mutex_init(&mutex, NULL);

    pthread_create(&threads[], NULL, worker_one, NULL);

    pthread_create(&threads[], NULL, worker_two, NULL);

    pthread_create(&threads[], NULL, worker_three, NULL);

    pthread_join(threads[], NULL);

    pthread_join(threads[], NULL);

    pthread_join(threads[], NULL);

    printf("Value started at %d and ends with %d.\n", , counter);

    return ;

}

void * worker_one() {

    printf("Worker one started.\n");

    pthread_mutex_lock(&mutex);

    printf("Worker one starting work.\n");

    while (counter < ) {

        counter += ;

    }

    pthread_cond_signal(&cond_a);

    printf("Worker one finished work with: %d.\n", counter);

    pthread_mutex_unlock(&mutex);

    pthread_exit(NULL);

}

void * worker_two() {

    printf("Worker two started.\n");

    pthread_mutex_lock(&mutex);

    pthread_cond_wait(&cond_a, &mutex);

    printf("Worker two starting work.\n");

    while (counter > )

        counter -= ;

    printf("Worker two finished work with: %d.\n", counter);

    pthread_cond_signal(&cond_b);

    pthread_mutex_unlock(&mutex);

    sleep();

    pthread_exit(NULL);

}

void * worker_three() {

    printf("Worker three started.\n");

    pthread_mutex_lock(&mutex);

    pthread_cond_wait(&cond_b, &mutex);

    printf("Worker three starting work.\n");

    counter /= ;

    printf("Worker three finished work with: %d.\n", counter);

    pthread_mutex_unlock(&mutex);

    pthread_exit(NULL);

}

For some reason the whole execution hangs around the first thread. The signal is also fired but thread two does not react.

Can somebody tell me what I am doing wrong?

 
Could somebody tell me why down vote? – bodokaiser May 29 '13 at 16:23
    
I've moved the code from gist to SO. Don't just link to code on an external site, please include relevant code in the question. – user7116 May 29 '13 at 16:25
    
ok did not knew anything about this – bodokaiser May 29 '13 at 16:25

6 down vote accepted

 

I have answered a similar question here: pthread condition variables on Linux, odd behaviour.

The problem is that you wait before even testing the condition you want to wait for is true. What happens is that thread 1 signals before thread 2 is waiting, therefore the signal is lost and thread 2 will be waiting forever.

In order to avoid this, first test what you want to wait for, then wait only if it's not here.

EDIT: Ok, here is a possible solution with only one mutex and one condtion (untested)

Thread 1:

 
pthread_mutex_lock(&mutex);

while(thread_1_should_work == false){ // wait until the condition is satisfied

  pthread_cond_wait(&cond, &mutex);

}

//at this point, we owe the mutex and we know thread_1_should_work is true; 

// do work 

thread_1_shoudl_work = false;

thread_2_should_work = true; 

pthread_cond_broadcast(&cond); //wake up any waiting thread (if it's not their turn, they'll call wait again)

pthread_mutex_unlock(&mutex);
Is the testing case a simple external flag or something pthread internal? I use the example from computing.llnl.gov/tutorials/pthreads but there are no flags actually – bodokaiser May 29 '13 at 16:33
 
 
@bodokaiser: you'll have to make up a variable, but a simple boolean flag will do. Spurious wakeups are a reality unfortunately. – user7116 May 29 '13 at 16:35
 
@sixlettervariables so the main idea of conditions are just some more specific mutex signaling (with out the actual locking). Is this correct? – bodokaiser May 29 '13 at 16:36
 
Yes, in your case is thread_is_working flag would work (except that it has more than 6 letters :) I think the answer that the linked answer can help. – Ben May 29 '13 at 16:38
 
Actually, wait() releases the mutex and yield the thread atomically so that nothing happens while the thread is being yield. – Ben May 29 '13 at 16:41

相关文章