As we know, pthread_cond_wait(cond, mutex) first unlock the mutex and wait. When it is waked up on condition variable, it has to lock the mutex.
Now my question is: what if it's waked up but found the mutex is already locked by someone else? What shall it do? Will it go back to sleep(wait) or just give up?
Yeah... I am trying to remember the correct euphamism for this one... The spaghetti eating philosopher's paradox, methinks.
>> What if it's waked up but found the mutex is already locked by someone else?
Not a relevant question for a user of the function. All the user needs to know is that: "Upon successful return, the mutex shall have been locked and shall be owned by the calling thread."
gg
The implementation will wait until it can lock the mutex. Then it will check the condition. If it's false, it will unlock the mutex and go back to sleep.
All the buzzt!
CornedBee
"There is not now, nor has there ever been, nor will there ever be, any programming language in which it is the least bit difficult to write bad code."
- Flon's Law
That isn't true. The mutex might be re-acquired even though the condition no longer holds. This is why all calls to pthread_cond_wait() should be wrapped in a while (not an if!) which tests the condition. Some other thread could intervene and cause the condition to become untrue even though the testing thread has woken up.Originally Posted by CornedBee
In general:
Code:pthread_mutex_lock(&mut); while(!some_condition) { pthread_cond_wait(&cond, &mut); } /* Do something to the state... */ pthread_mutex_unlock(&mut);
Code://try //{ if (a) do { f( b); } while(1); else do { f(!b); } while(1); //}
Sorry, I forgot that most condition variables don't actually have the condition integrated.
All the buzzt!
"There is not now, nor has there ever been, nor will there ever be, any programming language in which it is the least bit difficult to write bad code."
- Flon's Law
In terms of what's going on inside pthread_cond_wait(), that's basically what it's doing. Where "check the condition" == "check if the pthread_cond_t is signaled".
In terms of the external predicate associated with the pthread_cond_t, brewbuck is also right due to "spurious wakeups". This is where multiple threads waiting on the same condition can successfully return from pthread_cond_wait() after a single call to pthread_cond_signal().
More reading on "spurious wakeups" in the "Rationale" section here: http://www.opengroup.org/onlinepubs/...nd_signal.html
gg
