Alternate between 2 threads - c

Question

I wanted to make a program that writes the odd and even numbers between 1 and 100 with 2 functions , the first function prints the first 5 odd numbers , the second function prints the first 5 even numbers and again we return to the first function to print the second 5 odd numbers and so on .
In this program i wanted to alternate between only 2 threads , but i can't find the solution . Here's my code , in this code i created 40 threads.Does anyone knows how to alternate between 2 threads and find the same output.
#include<stdio.h>
#include<pthread.h>
pthread_t tid[40];
int pair=2;
int impair=1 ;
pthread_mutex_t lock;
void* genpair(void *arg)
{
pthread_mutex_lock(&lock);
int i = 0;
for (i=0 ; i<5 ; i++,pair+=2)
{
printf("%d ",pair) ;
}
printf(" ");
pthread_mutex_unlock(&lock);
return NULL;
}
void* genimpair(void *arg)
{
pthread_mutex_lock(&lock);
int i = 0;
for (i=0 ; i<5 ; i++,impair+=2)
{
printf("%d ",impair) ;
}
printf(" ");
pthread_mutex_unlock(&lock);
return NULL;
}
int main(void)
{
int i = 0;
int j=0 ;
int err;
if (pthread_mutex_init(&lock, NULL) != 0)
{
printf("\n mutex init failed\n");
return 1;
}
for(j=0 ; j<20 ; j+=2)
{
pthread_create(&(tid[j]), NULL, &genpair, NULL);
pthread_create(&(tid[j+1]), NULL, &genimpair, NULL);
pthread_join(tid[j], NULL);
pthread_join(tid[j+1], NULL);
}
pthread_mutex_destroy(&lock);
return 0;
}

Answer 1

You cannot ensure which thread will be able to pass before the other with mutexes only. A mutex is there only to ensure that only one thread will be able to run the critical code. You can use a conditional variable associated to your mutex to make them pass one after the other, as in the following pseudo code:
// thread1
do {
lock(m);
while (turn==0) cond_wait(m); // release the key if not my turn, retry until my turn
do my job;
turn = 0; // give hand to the other
cond_broadcast(m); // awake threads waiting for key (blocked in lock or cond_wait)
unlock(m); // release the lock
} while ();
// thread2
do {
lock(m);
while (turn==1) cond_wait(m);
do my job;
turn = 1;
cond_broadcast(m);
unlock(m);
} while();
You can also use two semaphores for the same job...

Answer 2

You must use 2 different mutex and your code be like this
//Thread pair
{
pthread_mutex_lock(&pairLock)
//Do pair job
pthread_mutex_unlock(&impairLock)
}
//Threa impair
{
pthread_mutex_lock(&impairLock)
//Do impair job
pthread_mutex_unlock(&pairLock)
}
The mutex of the starting thread must start at 1 (unlocked) and the other one at 0 (locked)
Edit: Using the same mutex for all your threads makes that only one thread can do it's job but doesn't force any order or alternance (Depends on system scheduler). In your case genimpair could execute first if scheduler says so, but it won't be interrupted by genpair, in the next loop it could be same order or not