My recommendation is typically to keep the pthread_cond_signal() call
inside the locked region, but probably not for the reasons you think.
In most cases, it doesn't really matter whether you call pthread_cond_signal() with
the lock held or not. Ben is right that some schedulers may force a context switch when the lock is released if there is another thread waiting, so your thread may get switched away before it can call pthread_cond_signal().
On the other hand, some schedulers will run the waiting thread as soon as you call pthread_cond_signal(),
so if you call it with the lock held, the waiting thread will wake up and then go right back to sleep (because it's now blocked on the mutex) until the signaling thread unlocks it. The exact behavior is highly implementation-specific and may change between
operating system versions, so it isn't anything you can rely on.
But, all of this looks past what should be your primary concern, which is the readability and correctness of your code. You're not likely to see any real-world performance benefit from this kind of micro-optimization (remember the first rule of optimization:
profile first, optimize second). However, it's easier to think about the control flow if you know that the set of waiting threads can't change between the point where you set the condition and send the signal. Otherwise, you have to think about things like"what
if thread B sets testCondition=TRUE and
releases the lock, and then thread A runs and sees that testCondition is
true, so it skips the pthread_cond_wait() and
goes on to reset testCondition to FALSE,
and then finally thread B runs and calls pthread_cond_signal(),
which wakes up thread C because thread A wasn't actually waiting, but testCondition isn't
true anymore". This is confusing and can lead to hard-to-diagnose race conditions in your code. For that reason, I think it's better to signal with the lock held; that way, you know that setting the condition and sending the signal are atomic with respect
to each other.
On a related note, the way you are calling pthread_cond_wait() is
incorrect. It's possible (although rare) for pthread_cond_wait() to
return without the condition variable actually being signaled, and there are other cases (for example, the race I described above) where a signal could end up awakening a thread even though the condition isn't true. In order to be safe, you need to
put the pthread_cond_wait() call
inside a while() loop
that tests the condition, so that you call back into pthread_cond_wait() if
the condition isn't satisfied after you reacquire the lock. In your example it would look like this:
pthread_mutex_lock(&my_lock);
while ( false == testCondition ) {
pthread_cond_wait(&my_wait,&my_lock);
}
pthread_mutex_unlock(&my_lock);
(I also corrected what was probably a typo in your original example, which is the use of my_mutex for
the pthread_cond_wait() call
instead of my_lock.)
