pthreads - reading and writing to global variables - pthreads

Question

I am learning about pthreads and I've created a program that creates 10 threads of which 5 read the value of a global variable and 5 update the value of a global variable. Here is some sample output from the program.
My question is why in the write() thread does it always say that the shared variable is 2 even though it is being updated each time a write() thread is created? I would of expected it to change.
Output:
Write thread - shared variable was 2 and it is now 22
Read Thread - The shared variable is 2
Write thread - shared variable was 2 and it is now 9
Write thread - shared variable was 2 and it is now 12
Write thread - shared variable was 2 and it is now 37
Write thread - shared variable was 2 and it is now 43
Read Thread - The shared variable is 2
Read Thread - The shared variable is 43
Read Thread - The shared variable is 43
Read Thread - The shared variable is 43
The code:
#include <stdlib.h>
#include <pthread.h>
#include <string.h>
#include <stdio.h>
#define NUM_THREADS 5
int shared_varibale = 2;
void *read(void *param);
void *write(void *param);
int main (int argc, char *argv[]) {
int i;
time_t t;
pthread_t tid[NUM_THREADS];
/* Intializes random number generator */
srand((unsigned) time(&t));
/*Create 5 write threads*/
for(i = 0; i < NUM_THREADS; i++) {
pthread_create(&tid[i], NULL, write, &shared_varibale);
}
/*Create 5 read threads*/
for(i = 0; i < NUM_THREADS; i++) {
pthread_create(&tid[i], NULL, read, &shared_varibale);
}
return 0;
}
void *read(void *param) {
int *p = (int*)param;
printf("The variable is %d\n", *p);
pthread_exit(NULL);
}
void *write(void *param) {
int *p = (int*)param;
int rand_varibale = rand() % 50;
printf("Write thread - shared variable was %d and it is now %d\n", *p, rand_varibale);
*p = rand_varibale;
pthread_exit(NULL);
}

Answer 1

First of all, you should not call your own functions read or write because POSIX already uses these identifiers. You should also add error checking to all function calls because it is easy to miss problems if you do not do that.
There is no synchronization in your example, so you have a data race. Among other things, this means that the threads may see an outdated value. And you do not impose any order on the execution of the threads. If your hardware supports that much parallelism, it is likely that all threads execute until the printf call (which causes all of them except one to block). Since the shared variable is only written to after the printf call, you get the results you see.