pthread_cond_wait无法解锁互斥锁

Question

In the first place, my problem is different.

In my scenario, there is one waiting thread, which waits on condition variable. Signalling thread signals conditional variable.

My code is

//Wating thread

//Lock the mutex_
//mutex_ is of pthread_mutex_t  and is initialized.
result = pthread_mutex_lock(&mutex_);
assert(result == 0);

do {
    //Wait on condition variable cvar_
    //cva_ is of pthread_cond_t  and is initialized.
    result = pthread_cond_wait(&cvar_, &mutex_);  //POINT 1
}while(result == 0 && !state_);

//Unlock the mutex_.
result = pthread_mutex_unlock(&mutex_);

//signalling thread
result = pthread_mutex_lock(&mutex_); //POINT 2
assert(result == 0);
state_ = 1;
result = pthread_mutex_unlock(&mutex_);
assert(result == 0);

//signals the condition variable.
pthread_cond_signal(&cvar_);

My operating system is Mac OS X 10.8 but minimum target is 10.6
This is running fine without any problem in almost every cases except one.

In a particular case, I notices that after POINT 1 that is pthread_cond_wait , mutex_ is not unlocked when it enters into wait state. This I confirmed by pthread_mutex_trylock which returns EBUSY in this case. And due to this, signalling thread goes into wait and ultimately results in a deadlock.

I would like to know under what condition, pthread_cond_wait does not unlock the mutex passed to it. What is the cause of this problem?

Answer 1

As @KenThomases pointed out: your problem is that you are missing the signal, not that the signal isn't getting sent. The signalling thread is calling pthread_cond_signal() before the waiting thread calls pthread_cond_wait() . pthread_cond_wait() should only be called after you've tested that the invariants you are looking for aren't currently met:

while (!state_) {
  result = pthread_cond_wait(&cvar_, &mutex_);
  if (result == EINVAL) ... // error handling
}

The other thing that can help sometimes is to put the signalling thread's call to pthread_cond_signal() inside the critical section. This isn't necessary to fix your problem, but can make the program easier to reason about because you know that no-one else is holding the mutex at the time you signal them:

// signalling thread
...
result = pthread_mutex_lock(&mutex_);
...
state_ = 1;
//signals the condition variable.
pthread_cond_signal(&cvar_);
result = pthread_mutex_unlock(&mutex_);
...

Answer 2

After reading about pthread_setcancelstate , I found that pthread_cond_wait is a cancellation point of the thread. If cancel is enabled for the thread and is deferred, then cancellation point will test for cancel. If any cancel is pending, thread will exit.

So, in my case, thread exits leaving mutex_ locked. Therefore signalling thread blocks.

But there is one more doubt. All the threads are being created from the same function using Thread class. Why only this thread has got such behaviour of cancellation?