Global Variables

It is very important to remember that all threads and the main program run in the same address space allocated to the main program. This implies that names declared as external can be accessed by all threads. However, names declared local to a function are still local to that function.

Example

Let us consider the following program. You can click here to download a copy.

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

#define   MAX_ITERATION  2000

int       Counter = 0;

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

     for (i = 1; i <= MAX_ITERATION; i++) {
          Counter++;
          printf("Thread Counting() has updated the counter to %d\n", Counter);
     }          
     thr_exit(0);
}

void  *Peeking(void *DontNeedIt)
{
     int  i;
     int  j, k;

     for (i = 1; i <= MAX_ITERATION; i++)
          if (i % 100 == 0)
               printf("     Thread Peeking() saw the counter as %d\n", Counter);
          else           /* the following is a dummy loop */
               for (j = k = 0; j <= MAX_ITERATION/2; j++, k += j)
                    ;
     thr_exit(0);
}

void  main(void)
{
     thread_t  FirstThread, SecondThread;
     size_t    StatusFromA, StatusFromB;

     thr_create(NULL, 0, Counting, (void *) NULL, 0, &FirstThread);
     thr_create(NULL, 0, Peeking, (void *) NULL, 0, &SecondThread);

     thr_join(FirstThread, 0, (void *) &StatusFromA);
     thr_join(SecondThread, 0, (void *) &StatusFromB);
}

• The main program creates two threads by running functions Counting() and Peeking().
• Function Counting() has a loop which iterates MAX_ITERATION times. In each iteration, the value of a global variable Counter is increased and displayed.
• Function Peeking() also has a loop which iterates MAX_ITERATION times. However, the value of the global variable Counter is only displayed every 100 iterations. If the iteration number is not a multiple of 100, this function just executes a dummy loop to waist time.
• Since variable Counter is global, the main program and both functions can have access to it. On the other hand, since variable i is declared locally, the copy in function Counting() can only be used within that function.
• What is the output? This is a question that cannot be answered precisely, since it depends on the relative speed of the two threads and other external factors such as system load, CPU speed and so on. More precisely, if a variable is shared by threads, it is very difficult to predict its value. In other words, the behavior of a multithreaded program is dynamic. Therefore, debugging is very difficult, because a bug may never appear if all the influential factors do not have a right mix. In a sequential program, if it has a bug, it appears at the same place every time you run the program. In a multithreaded program, a bug many never appear or it may appear in this run and disappear in the next run. Consequently, writing multithreaded program requires a very careful thinking and planning of your logic and your algorithm.