Print 1 2 3 infinitely using threads in C

Print 1 2 3 infinitely using thread. Create three threads viz T1, T2, and T3 such that those should print 1 2 3 sequence infinitely. Examples :

Output :1 2 3 1 2 3 1 2 3 1 2 3 1 2 3 ......

Prerequisite : Threads in C Approach :

Start an infinite loop and initialize a variable 'done' to 1.
Now, check for the value of done is not equal to 1.
If it is hold wait condition lock, else print n and respectively signal the next consecutive n.

CPP

// C code to print 1 2 3 infinitely using pthread
#include <stdio.h>
#include <pthread.h>

// Declaration of thread condition variables
pthread_cond_t cond1  = 
               PTHREAD_COND_INITIALIZER;
pthread_cond_t cond2  = 
               PTHREAD_COND_INITIALIZER;
pthread_cond_t cond3  = 
               PTHREAD_COND_INITIALIZER;

// mutex which we are going to
// use avoid race condition.
pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
 
// done is a global variable which decides 
// which waiting thread should be scheduled
int done = 1;
 
// Thread function
void *foo(void *n)
{
        while(1) {
                
                // acquire a lock
                pthread_mutex_lock(&lock);
                 
                if (done != (int)*(int*)n) {
                        
                        // value of done and n is not equal,
                        // hold wait lock on condition variable
                        if ((int)*(int*)n == 1) {
                                pthread_cond_wait(&cond1, &lock);
                        } else if ((int)*(int*)n == 2) {
                                pthread_cond_wait(&cond2, &lock);
                        }
                        else {
                                pthread_cond_wait(&cond3, &lock);
                        }
 
                }
                // done is equal to n, then print n
                printf("%d  ", *(int*)n);
 
                // Now time to schedule next thread accordingly 
                // using pthread_cond_signal()
                if (done == 3) {
                        done = 1;
                        pthread_cond_signal(&cond1);
                }
                else if(done == 1) {
                        done = 2;
                        pthread_cond_signal(&cond2);
                } else if (done == 2) {
                        done = 3;
                        pthread_cond_signal(&cond3);
                }
                
                // Finally release mutex
                pthread_mutex_unlock(&lock);
        }
 
        return NULL;
}

// Driver code
int main()
{
        pthread_t  tid1, tid2, tid3;
        int n1 = 1, n2 = 2, n3 = 3;
        
        // Create 3 threads 
        pthread_create(&tid1, NULL, foo, (void *)&n1);
        pthread_create(&tid2, NULL, foo, (void *)&n2);
        pthread_create(&tid3, NULL, foo, (void *)&n3);
        
        // infinite loop to avoid exit of a program/process
        while(1);
        
        return 0;
}

Output :

1 2 3 1 2 3 1 2 3 1 2 3 ...

Print 1 2 3 infinitely using threads in C

Explore