Thread: Unexpected behaviour of pthread_cond_broadcast

I wrote a small code sample that starts a number of counting and a number of waiting threads.
The waiting threads are stopped `pthread_cond_wait` until they receive a signal. The signal is sent after the counting threads finish their tasks.


The waiting threads receive their signal and each thread prints out its given, unique id.


I would expect all waiting threads to receive the signal at the same time, so that each of them can proceed with the program. I noticed however, the outputs are not chaotic, in fact they even appear to be fairly ordered, like in FILO!


There are now various places, where I could have gone wrong.


Here is my code:

Code:

    #include <pthread.h>
    #include <stdio.h>
    #include <stdlib.h>
    
    #define counting_threads 100
    #define waiting_threads 100
    
    int count = 0;
    int counting_thread_ids[counting_threads];
    int waiting_thread_ids[waiting_threads];
    pthread_mutex_t count_mutex;
    pthread_cond_t count_threshold_cv;
    
    
    void init_ids(){
    	for(int i = 0; i < counting_threads; i++)
    		counting_thread_ids[i] = 2*i;
    	for(int j =0; j < waiting_threads; j++)
    		waiting_thread_ids[j] = 2*j+1; 	
    }
    
    void counting(void *t) 
    {
    	pthread_mutex_lock(&count_mutex);
    	count++;
    
        if (count == counting_threads) {
    	sleep(2);
          printf("inc_count(): count = %d  Threshold reached. Signaling waiting threads. \n", count);
               //~ pthread_cond_signal(&count_threshold_cv);           
               pthread_cond_broadcast(&count_threshold_cv); 
          }
        pthread_mutex_unlock(&count_mutex);
        }
    
    void *waiting(void *t) 
    {
      long my_id = (long)t;
      //~ printf("Starting watch_count(): thread %ld\n", my_id);
    
      pthread_mutex_lock(&count_mutex);
    
        //~ printf("watch_count(): I start waiting now: %ld \n", my_id);
        pthread_cond_wait(&count_threshold_cv, &count_mutex);
        printf("watch_count(): thread %ld Condition signal received.\n", my_id);
    	pthread_mutex_unlock(&count_mutex);
    	pthread_exit(NULL);
    }
    
    int main (int argc, char *argv[])
    {
    	init_ids(); 
    	
    	pthread_t wt[waiting_threads];
    	pthread_t ct[counting_threads];  
    	
      /* Initialize mutex and condition variable objects */
      pthread_mutex_init(&count_mutex, NULL);
      pthread_cond_init (&count_threshold_cv, NULL);
    
    	for(int i = 0; i < waiting_threads; i++)
    		pthread_create(&wt[i], NULL, waiting, (void*) waiting_thread_ids[i] );
    	for(int i = 0; i < counting_threads; i++)
    		pthread_create(&ct[i], NULL, counting, (void*) counting_thread_ids[i] );
    	
    	
      /* Wait for all threads to complete */
      for (int i=0; i<waiting_threads; i++) {
        pthread_join(wt[i], NULL);
      }
      for (int i=0; i<counting_threads; i++) {
        pthread_join(ct[i], NULL);
      }
    
    
      /* Clean up and exit */
      pthread_mutex_destroy(&count_mutex);
      pthread_cond_destroy(&count_threshold_cv);
      pthread_exit(NULL);
    
    }