Synchronization primitives: Mutex and Semaphore - Article 4

In this article, lets deep dive and understand the synchronization primitives - Mutex and Semaphore.

Mutex or Mutual Exclusion is the basic form of synchronization primitive. Its a locking mechanism and ensures that only one thread or process can enter the critical section. After finishing the work (Like updating global variable or a data structure), the thread unlocks the mutex.

NOTE: Mutex is used to synchronize threads. However, latest addition to POSIX standard says that the mutex can be used to synchronize processes if it's shared between them.

A real world example follows: In olden days when there were no mobile phones, love birds (I mean lovers) used the STD phone booth extensively. What would they do? enter the phone booth, lock it and dial their partners home phone and start off on a long call - Outside, you could see a long line of people cursing the guy inside and waiting to get into the booth.

i.e., one and only thread or process (Person) needs to enter critical section (Phone booth), lock the mutex (Lock the booth), process the data (Call the partner) and unlock and leave the critical section (Hang up phone and come out of the booth).

Similarly, the other threads trying to lock the mutex are added to the wait Q. After the mutex is unlocked, one thread or all the threads may be woken up by the scheduler in OS which is implementation dependent.

This is the pseudo code for mutex:

// Declare a mutex
Mutex OnlyOneThread;

 // Share the mutex between say 5 threads

 OnlyOneThread.lock();
    // Critical section code here like updating a shared linked list
OnlyOneThread.unlock();

Semaphore is a signalling mechanism which can be used for serialization.

For example, you and your friend are planning to go for a movie and your friend will say to you to leave only after he/she calls you.

The pseudo code is like below:

Your friend:

 Leave to Movie;
Call to signal;

 You:

 Wait for call;
Leave to Movie;

 i.e., You don't leave to movie until you get a call from your friend.

Whatever we have seen is just the tip of the ice berg. In the next article, we shall go further deep and see how exactly Semaphore is implemented and how it can be used to solve serialization problems.

Comments

Post a Comment

Popular posts from this blog

Synchronization primitives: Mutex and Semaphore (Serialization & Mutex problems using Semaphore) - Article 6

Hi Friends, In the previous articles, we have gained knowledge about Mutex and Semaphore. In this article, we shall see how a Semaphore can be used to solve serialization problem and Mutual Exclusion (Mutex) problem. Serialization problem: Thread 1: Event A; // Could be any code Thread 2: Event B; // Could be any code The problem is, we have to ensure that Event B or a particular code or instructions should always be executed after Event A or some other particular code. Basically, we are serializing the instructions irrespective of how the threads are scheduled to run. Solution: There are no resources here, we need to just signal, initialize Semaphore to 0. Semaphore SignalThread2 = 0; Thread 1: Event A; SignalThread2.signal(); Thread 2: SignalThread2.wait(); Event B; The code for Thread 1 and Thread 2 is as above. Irrespective of which thread is scheduled, Event A always occurs before Event B. How? Let's say Thread 2 is scheduled first, it executes
Read more

Synchronization: Discussion about Mutex and Semaphore - Article 1

This is the first article in the series about Mutex and Semaphore. In my blog, I shall follow below sequence: 1. First, I will try to explain the concept. 2. Next, we shall see what problems the concept may solve or what problems may occur if the concept is not applied. 3. Finally, we shall see how the concept will solve the problem. In this article, I will try to cover what Synchronization in Computers is all about and different problems that can occur if Synchronization is not used. First we will see the real world examples and see what Synchronization is all about. Dictionary meaning is as below: 1. To cause to occur or operate with exact coincidence in time or rate. 2. Synchronization is the coordination of events to operate a system in unison. Let's try to understand in depth. Consider below examples: 1. Imagine soldiers doing march past in a parade. - They operate at the same time and everybody march in order. - They appear synchronized. How do they do it? - Every
Read more

Copy constructor in C++ (Part 2)

Now, the important question comes is regarding the signature of copy constructor. That is, why copy constructor takes a reference as parameter. Let's copy by value from previous example. CopyDemo(const CopyDemo obj) {     ptr = new int;     *ptr = *obj.ptr; } Now from main(), CopyDemo o2 = o1; Let me explain in detail. We have called copy constructor to copy o1 to o2. But, since we are passing by value, first o1 has to be copied to obj. So internally, statement will be, const CopyDemo obj = o1; Now, what happens is again copy constructor is invoked. Already, we can sense some problem, copy constructor is called again. Internally, the statement is repeated again. const CopyDemo obj = o1; This goes into a recursive loop and following statements get repeated till stack overflow happens and ultimately program crashes. const CopyDemo obj = o1; const CopyDemo obj = o1; const CopyDemo obj = o1; . . .
Read more