Example for using shared data between two Unix threads

Following is the simple example to show, how we can create two threads at a time and make one thread locked on a mutex, till another thread releases previously acquired mutex so that both the threads doesn’t access / try to modify shared variable simultaneously giving us an unpredected result. In below program, for demostration, we have created a global variable to which we try to add 5 from one thread and substract 3 from another thread. #include <pthread.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h> int global_sum = 0; pthread_t tid1, tid2; pthread_mutex_t mutex_lock; void *function_shared_between_threads(void *arg) { int i; int *passed_value = (int*)arg; printf("called from : %d \n", *passed_value); pthread_mutex_lock (&mutex_lock); for (i=0; i < 5; i++) { printf("adding : %d \n : final sum: %d", *passed_value, global_sum); global_sum += *passed_value; sleep(1); } pthread_mutex_unlock (&mutex_lock); pthread_exit((void*) 0); } int main (int argc, char *argv[]) { int val1 = 5; int val2 = -2; void *status; printf("Executing main...\n"); pthread_mutex_init(&mutex_lock, NULL); printf("Creating Thread 1...\n"); pthread_create(&tid1, NULL, &function_shared_between_threads, (void *)&val1); printf("Creating Thread 2...\n"); pthread_create(&tid2, NULL, &function_shared_between_threads, (void *)&val2); printf("Waiting for Thread 1 to complete...\n"); pthread_join(tid1, &status); printf("Waiting for Thread 2 to complete...\n"); pthread_join(tid2, &status); pthread_mutex_destroy(&mutex_lock); printf("Final Value : %d\n", global_sum); pthread_exit(NULL); return 0; } Compile the program by linking pthread library as, $ gcc -o shared_data_between_threads shared_data_between_threads.c -lpthread $ ./shared_data_between_threads Executing main...

Command line execution

$ gcc -o shared_data_between_threads shared_data_between_threads.c -lpthread  $ ./shared_data_between_threads  Executing main... Creating Thread 1... Creating Thread 2... Waiting for Thread 1 to complete... called from : -2  called from : 5  adding : 5 : final sum: 0 adding : 5 : final sum: 5 adding : 5 : final sum: 10 adding : 5 : final sum: 15 adding : 5 : final sum: 20 adding : -2 : final sum: 25 Waiting for Thread 2 to complete... adding : -2 : final sum: 23 adding : -2 : final sum: 21 adding : -2 : final sum: 19 adding : -2 : final sum: 17 Final Value : 15 As we see above, if we use proper pthread_lock, although both threads are created at a time, thread which adds 5, continues to operate on global_sum till it completes its 5 iterations and we see 5 getting added uniformly and once first thread releases the lock, second thread which was waiting continues with the operations. Now, lets try to remove the mutex lock and see, how we get the output. #include <pthread.h> #include <stdio.h> #include <stdlib.h> #include <unistd.h>   int global_sum = 0;   pthread_t tid1, tid2;   void *function_shared_between_threads(void *arg) {     int i;     int *passed_value = (int*)arg;       printf("called from : %d \n", *passed_value);     for (i=0; i < 5; i++) {         printf("adding : %d : final sum: %d\n", *passed_value, global_sum);         global_sum += *passed_value;         sleep(1);     }     pthread_exit((void*) 0); }   int main (int argc, char *argv[]) {     int val1 = 5;     int val2 = -2;     void *status;     printf("Executing main...\n");                    printf("Creating Thread 1...\n");     pthread_create(&tid1, NULL, &function_shared_between_threads, (void *)&val1);     printf("Creating Thread 2...\n");     pthread_create(&tid2, NULL, &function_shared_between_threads, (void *)&val2);       printf("Waiting for Thread 1 to complete...\n");     pthread_join(tid1, &status);     printf("Waiting for Thread 2 to complete...\n");     pthread_join(tid2, &status);       printf("Final Value : %d\n", global_sum);     pthread_exit(NULL);     return 0; }  $ ./shared_data_between_threads Executing main... Creating Thread 1... Creating Thread 2... Waiting for Thread 1 to complete... called from : 5  adding : 5 : final sum: 0 called from : -2  adding : -2 : final sum: 5 adding : 5 : final sum: 3 adding : -2 : final sum: 3 adding : 5 : final sum: 6 adding : -2 : final sum: 6 adding : 5 : final sum: 9 adding : -2 : final sum: 14 adding : 5 : final sum: 12 adding : -2 : final sum: 17 Waiting for Thread 2 to complete... Final Value : 15 As, we can see, if we dont use pthread_mutex_lock both threads tries to access and update global_sum resulting some random behaviour as we see in prints above.

Implementation details

Creating Thread 1... Creating Thread 2... Waiting for Thread 1 to complete... called from : -2 called from : 5 adding : 5 : final sum: 0 adding : 5 : final sum: 5 adding : 5 : final sum: 10 adding : 5 : final sum: 15 adding : 5 : final sum: 20 adding : -2 : final sum: 25 Waiting for Thread 2 to complete... adding : -2 : final sum: 23 adding : -2 : final sum: 21 adding : -2 : final sum: 19 adding : -2 : final sum: 17 Final Value : 15 As we see above, if we use proper pthread_lock, although both threads are created at a time, thread which adds 5, continues to operate on global_sum till it completes its 5 iterations and we see 5 getting added uniformly and once first thread releases the lock, second thread which was waiting continues with the operations.

Gotchas and common issues

• Permission checks - verify user access rights and sudo privileges before executing system-level operations.

• Environment configuration - double-check path variables and dependency versions to prevent runtime failures.

• Backup safeguards - maintain configuration backups before applying system or database modifications.

Following these steps ensures clean configuration and reliable execution for example for using shared data between two unix threads.