#include <pthread.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

#define NUM_T1       4
#define NUM_T2	     4

bool done = false;
int count = 0 ;
pthread_mutex_t count_mutex;

void *T1(void *t)
{
   int tid = *((int*)t);
   printf("Thread %d started.\n",tid);
        while(!done) {
                pthread_mutex_lock(&count_mutex);
                count++ ;
                printf("T1 [%d] count = %d\n", tid, count);
                pthread_mutex_unlock(&count_mutex);
                sleep(1);
        }
   printf("T1 thread %d done.\n",tid);
   pthread_exit(NULL);
}

void *T2(void *t)
{
   long tid = *((int*)t);
   printf("Thread %d started.\n",tid);
        while(!done) {
                pthread_mutex_lock(&count_mutex);
                count-- ;
                printf("T2 [%d] count = %d\n", tid, count);
                pthread_mutex_unlock(&count_mutex);
                sleep(2);
        }
   printf("T2 thread %d done.\n",tid);
   pthread_exit(NULL);
}


int main (int argc, char *argv[])
{
   pthread_t thread[NUM_T1 + NUM_T2];
   pthread_attr_t attr;
   int t;
   void *status;


   /* Initialize mutex and condition variable objects */
   pthread_mutex_init(&count_mutex, NULL);
   //pthread_cond_init (&count_cond, NULL);

   /* Initialize and set thread detached attribute */
   pthread_attr_init(&attr);
   pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);

   for(t=0; t<NUM_T1; t++) {
      pthread_create(&thread[t], &attr, T1, (void *)&t); 
   }
      
   for(t=0; t<NUM_T2; t++) {
      pthread_create(&thread[t+NUM_T1], &attr, T2, (void *)&t); 
   }

   sleep(5);
   done = true ;
   /* Free attribute and wait for the other threads */
   for(t=0; t<NUM_T1+NUM_T2; t++) 
      pthread_join(thread[t], &status);
 
   printf("Main: program completed. Exiting. Count = %d\n",count);
   /* Clean up and exit */
   pthread_attr_destroy(&attr);
   pthread_mutex_destroy(&count_mutex);
   //pthread_cond_destroy(&count_cond);
   pthread_exit(NULL);

}

recondite> a.out
Thread 1 started.
T1 [1] count = 1
Thread 2 started.
Thread 1 started.
T1 [1] count = 2
T1 [2] count = 3
Thread 0 started.
T1 [0] count = 4
Thread 1 started.
T2 [1] count = 3
Thread 2 started.
T2 [2] count = 2
Thread 3 started.
T2 [3] count = 1
Thread 4 started.
T2 [4] count = 0
T1 [1] count = 1
T1 [1] count = 2
T1 [2] count = 3
T1 [0] count = 4
T2 [1] count = 3
T2 [2] count = 2
T1 [2] count = 3
T2 [4] count = 2
T2 [3] count = 1
T1 [0] count = 2
T1 [1] count = 3
T1 [1] count = 4
T1 [1] count = 5
T1 [2] count = 6
T1 [1] count = 7
T1 [0] count = 8
T2 [1] count = 7
T2 [2] count = 6
T2 [3] count = 5
T2 [4] count = 4
T1 [1] count = 5
T1 [2] count = 6
T1 [0] count = 7
T1 [1] count = 8
T1 thread 1 done.
T1 thread 0 done.
T1 thread 1 done.
T1 thread 2 done.
T2 thread 1 done.
T2 thread 2 done.
T2 thread 3 done.
T2 thread 4 done.
Main: program completed. Exiting. Count = 8
recondite>