C program on using Mutex Lock in Multi-Threaded Application
The most popular way of achieving thread synchronization is by
using Mutexes:
A
Mutex is a lock that we set before using a shared resource and release after
using it. When the lock is set, no other thread can access the locked region of
code. So we see that even if thread 2 is scheduled while thread 1 was not done
accessing the shared resource and the code is locked by thread 1 using mutexes
then thread 2 cannot even access that region of code. So this ensures a
synchronized access of shared resources in the code.
Internally
it works as follows :
Suppose
one thread has locked a region of code using mutex and is executing that piece
of code.
Now
if scheduler decides to do a context switch, then all the other threads which
are ready to execute the same region are unblocked.
Only
one of all the threads would make it to the execution but if this thread tries
to execute the same region of code that is already locked then it will again go
to sleep.
Context
switch will take place again and again but no thread would be able to execute
the locked region of code until the mutex lock over it is released.
Mutex
lock will only be released by the thread who locked it.
So
this ensures that once a thread has locked a piece of code then no other thread
can execute the same region until it is unlocked by the thread who locked it.
Hence,
this system ensures synchronization among the threads while working on shared
resources.
#include<stdio.h>
#include<string.h>
#include<pthread.h>
#include<stdlib.h>
#include<unistd.h>
pthread_t tid[2];
int counter;
pthread_mutex_t lock;
void* doSomeThing(void *arg)
{
pthread_mutex_lock(&lock);
unsigned long i = 0;
counter += 1;
printf("\n Job %d started\n", counter);
for(i=0; i<(0xFFFFFFFF);i++);
printf("\n Job %d finished\n", counter);
pthread_mutex_unlock(&lock);
return NULL;
}
int main(void)
{
int i = 0;
int err;
if (pthread_mutex_init(&lock, NULL) != 0)
{
printf("\n mutex init
failed\n");
return 1;
}
while(i < 2)
{
err = pthread_create(&(tid[i]),
NULL, &doSomeThing, NULL);
if (err != 0)
printf("\ncan't
create thread :[%s]", strerror(err));
i++;
}
pthread_join(tid[0], NULL);
pthread_join(tid[1], NULL);
pthread_mutex_destroy(&lock);
return 0;
}