#include <pthread.h>

pthread_mutex_t mutex;
pthread_cond_t cond;
int master_wakeup;

static void *thread_start(void *arg)
{
  pthread_mutex_lock(&mutex);
  while (master_wakeup)
    pthread_cond_wait(&cond, &mutex);
  pthread_mutex_unlock(&mutex);

  return 0;
}

int main(void)
{
  int i, t;
  pthread_t thread_id[5];

  pthread_mutex_init(&mutex, 0);
  pthread_cond_init(&cond, 0);

  for (i= 0; i < 1000; i++)
  {
    master_wakeup= 1;

    for (t= 0; t < 5; t++)
      if (pthread_create(&thread_id[t], 0, thread_start, 0))
        return 1;

    pthread_mutex_lock(&mutex);
    master_wakeup= 0;
    pthread_mutex_unlock(&mutex);
    pthread_cond_broadcast(&cond);

    for (t= 0; t < 5; t++)
      pthread_join(thread_id[t], 0);
  }

  pthread_mutex_destroy(&mutex);
  pthread_cond_destroy(&cond);

  return 0;
}

  These functions atomically release mutex and cause the calling thread to block
  on the condition variable cond; atomically here means "atomically with respect
  to access by another thread to the mutex and then the condition variable".
  That is, if another thread is able to acquire the mutex after the
  about-to-block thread has released it, then a subsequent call to
  pthread_cond_broadcast() or pthread_cond_signal() in that thread shall behave
  as if it were issued after the about-to-block thread has blocked.