Page History

When a given thread waits (cnd_wait() or cnd_timedwait()) on a condition variable, it can be awakened as result of a signal operation (cnd_signal()). However, if multiple threads are waiting on the same condition variable, any of those threads can be picked up by the scheduler to be awakened (assuming that all threads have the same priority level). 

This forces the The user is forced to create a predicate-testing-loop around the wait condition to guarantee that each thread only executes if only if its predicate test is true (recommendation on in IEEE Std 1003.1 since the 2001 release [IEEE Std 1003.1-2004]). As a consequence, if a given thread finds the predicate test to be false, it waits again, eventually resulting in a deadlock situation.

ThereforeConsequently, the use of cnd_signal() is safe only if the following conditions are met:

• All threads must perform the same set of operations after waking up. This means , which means that any thread can be selected to wake up and resume for a single invocation of cnd_signal().
• Only one thread is required to wake upon receiving the signal.

...

The use of cnd_broadcast() solves the problem since because it wakes up all the threads associated with the respective condition variable, and since all (must) re-evaluate all the threads must reevaluate the predicate condition, one should find its test to be true, avoiding the deadlock situation.

...

The following noncompliant code example consists on of a given number of threads (5) that should execute one after another according to the step level that is assigned to them when they are created (serialized processing). The current_step variable holds the current step level and is incremented as soon as the respective thread finishes its processing. Finally, another thread is signaled so that the next step can be executed.

#include <stdio.h>
#include <stdlib.h>
#include <threads.h>

#define NTHREADS  5

mtx_t mutex;
cnd_t cond;


void *run_step(void *t) {
  static int current_step = 0;
  int my_step = (int)t;
  int result;

  if ((result = mtx_lock(&mutex)) != thrd_success) {
    /* Handle error condition */
  }

  printf("Thread %d has the lock\n", my_step);

  while (current_step != my_step) {
    printf("Thread %d is sleeping...\n", my_step);

    if ((result = cnd_wait(&cond, &mutex)) != thrd_success) {
      /* Handle error condition */
    }

    printf("Thread %d woke up\n", my_step);
  }

  /* Do processing... */
  printf("Thread %d is processing...\n", my_step);

  current_step++;

  /* Signal a waiting task */
  if ((result = cnd_signal(&cond)) != thrd_success) {
    /* Handle error condition */
  }

  printf("Thread %d is exiting...\n", my_step);

  if ((result = mtx_unlock(&mutex)) != thrd_success) {
    /* Handle error condition */
  }

  thrd_exit(NULL);
}


int main(int argc, char** argv) {
  int i;
  int result;
  thrd_t threads[NTHREADS];
  int step[NTHREADS];

  if ((result = mtx_init(&mutex, mtx_plain)) != thrd_success) {
    /* Handle error condition */
  }
  if ((result = cnd_init(&cond)) != thrd_success) {
    /* Handle error condition */
  }

  /* Create threads */
  for (i = 0; i < NTHREADS; i++) {
    step[i] = i;
    if ((result = thrd_create(&threads[i], run_step, (void *)step[i])) != thrd_success) {
      /* Handle error condition */
    }
  }

  /* Wait for all threads to complete */
  for (i = NTHREADS-1; i >= 0; i--) {
    if ((result = thrd_join(threads[i], NULL)) != thrd_success) {
      /* Handle error condition */
    }
  }

  if ((result = mtx_destroy(&mutex)) != thrd_success) {
    /* Handle error condition */
  }
  if ((result = cnd_destroy(&cond)) != thrd_success) {
    /* Handle error condition */
  }

  thrd_exit(NULL);
}

In the above codethis example, each thread has its own predicate because each requires current_step to have a different value before proceeding. Upon the signal operation (pthread_cond_signal()), any of the waiting threads can wake up. If, by chance, it is not the thread with the next step value, that thread will wait again pthread_cond_wait(), thus resulting in a deadlock situation because no more signal operations will occur.

Consider the following example:

Therefore, this This noncompliant code example violates the [BB. Definitions#liveness[ liveness property.

Compliant Solution (Using cnd_broadcast())

...