Running Many Threads That Share a Global

The following program creates many threads running concurrently. All of them share the same global counter variable. Of these many threads, one of them is a counting thread that keeps increasing the counter, while all the others keep retrieving and displaying the value of the shared counter.

Click here to download a copy of this program.

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

#define   MAX_THREADS     10

int       MaxIteration;
int       Counter = 0;

void  *Display(void *ID)
{
     int  *intPTR = (int *) ID;
     int  MyID    = *intPTR;
     int  i;

     for (i = 1; i <= MaxIteration/2; i++)
          printf("Thread %d reporting --> %d\n", MyID, Counter);
     printf("Thread %d is done....\n", MyID);
     thr_exit(0);
}

void  *Counting(void *ID)
{
     int  i;

     while (1) {    /* this is an infinite loop */
          Counter++;
          if (Counter % 10 == 0)
               printf("\t\tFrom Counting(): counter = %d\n", Counter);
     }
}


void  main(int argc,  char *argv[])
{
     thread_t  ID[MAX_THREADS];
     size_t    Status;
     int       NoThreads, i, No[MAX_THREADS];

     if (argc != 3) {
          printf("Use %s #-of-threads #-of-iterations\n", argv[0]);
          exit(1);
     }
     NoThreads    = abs(atoi(argv[1]));
     MaxIteration = abs(atoi(argv[2]));
     if (NoThreads > MAX_THREADS) {
          printf("*** ERROR: too many threads ***\n");
          exit(0);
     }
     thr_create(NULL, 0, Counting, (void *) NULL, 0, NULL);
     for (i = 0; i < NoThreads; i++) {
          printf("Parent: about to create thread %d\n", i);
          No[i] = i;
          thr_create(NULL, 0, Display, (void *) (&(No[i])), 0, &(ID[i]));
     }
     for (i = 0; i < NoThreads; i++)
          thr_join(ID[i], 0, (void *) &Status);
}

• The main program reads in the number of threads and the number of iterations for each thread from command line argument into global variables NoThreads and MaxIteration. Then, the main program creates one counting thread and NoThreads display threads. After this, the main program just waits for the completion of all display threads. Note that the counting thread has an infinite loop.
• The display thread corresponds to function Display(). It takes an integer from its argument to be used as an identification number. Then, this thread iterates MaxIteration/2 times. In each iteration, this thread displays the current value of the shared counter variable.
• The counting thread corresponds to function Counting(). This thread is involved in an infinite loop. In each iteration, the value of the counter is increased and after every ten iterations the value of the counter is displayed. Note that once the main exits, the whole program, including this counting thread, exits.
• So, this program looks straightforward. But, it has a subtle problem. Consider the loop for creating all display threads, which is repeated below:

  for (i = 0; i < NoThreads; i++) {
       printf("Parent: about to create thread %d\n", i);
       No[i] = i;
       thr_create(NULL, 0, Display, (void *) (&(No[i])), 0, &(ID[i]));
  }
  

  Why is an array No[] used in the call to thr_create()? Could we just use a variable? In fact, we cannot use a variable. Here is why. If the call is changed to

  for (i = 0; i < NoThreads; i++) {
       printf("Parent: about to create thread %d\n", i);
       thr_create(NULL, 0, Display, (void *) (&i), 0, &(ID[i]));
  }
  

  then before the newly created thread takes the value of i, the for loop could come back and increases the value of i. As a result, the newly created thread will receive an incorrect value. This is why an array rather than a variable is used in the call.