Semaphore - Thread Synchronization

In this blog, you will learn about Semaphore, Thread Synchronization.

Introduction

Thread Synchronization ensures that two or more concurrent processes or threads do not simultaneously execute some particular program segments. It makes one thread wait, until it finishes other thread, when one thread already executes in the critical section. If proper synchronization techniques are not applied, it may cause race condition.

 

There are different ways to do thread synchronization. Locking is the famous way to to do thread synchronization. Basically, there are two kinds of locks - Exclusive and Non-Exclusive Lock.

 

A Non-Exclusive lock is a lock that notifies others that you are considering  changing the file. When you have a file locked non-exclusively, others can modify the file. Thus, Semaphore comes under the category of Non-Exclusive Lock. 

 

A Semaphore restricts the number of simultaneous users of the shared resources up to a maximum number. It ensures not more than a specific number of concurrent threads, which can access a resource.

 

A Semaphore is like a nightclub, it has a certain capacity, enforced by bouncer. Once it is full, no more people can enter and people wait outside in the form of queue. For each person that leaves, one people enters from the head of the queue into nightclub.

 

There are two functionalities- Semaphore and SemaphoreSlim. Semaphore incurs about 1 microseconds calling WaitOne or Release while SemaphoreSlim incurs about a quarter of it.

 

Example

This is a basic example of Semaphore, where 5 threads are wanted to enter and execute but, I will restrict it up to 3 threads, using Semaphore. 

using System;
using System.Text;
using System.Threading.Tasks;
using System.Threading;

namespace Semaphore
{
    public class TheSempahore
    {
        static SemaphoreSlim sema = new SemaphoreSlim(3);

        public static void StartExecute()
        {
            for (int i = 1; i <= 5; i++)
            {
                new Thread(Enter).Start(i);
            }
        }

        private static void Enter(object id)
        {
            Console.WriteLine("{0} wants to enter", id);
            sema.Wait();

            Console.WriteLine("Id {0} is in!", id);

            Thread.Sleep(1000 * (int)id);

            Console.WriteLine("{0} is leaving", id);

            sema.Release();
        }
    }
}


Now, Call the method into entry point:

class program
{

   public static void main()
     {
         TheSempahore.StartExecute();
         Console.readkey();
      }
}

Output

 

1 wants to enter

1 is in!

2 wants to enter

2 is in!

3 wants to enter

3 is in!

4 wants to enter

5 wants to enter

1 is leaving

4 is in!

2 is leaving

5 is in!

Example - Print Odd and Even numbers, using Thread.

public class OddEven
    {
        static SemaphoreSlim semaphoreSlim = new SemaphoreSlim(1, 1);
        static Thread Odd;
        static Thread Even;
        static LinkedList<int> Numbers = new LinkedList<int>();

        private static void PrintOdd()
        {
            while (Numbers.Count > 0)
            {
                semaphoreSlim.Wait();
                var a = Numbers.FirstOrDefault();
                if (a % 2 != 0)
                {
                    Console.WriteLine(Thread.CurrentThread.Name + " " + a);
                    Numbers.RemoveFirst();
                }
                semaphoreSlim.Release();
            }
        }
        private static void PrintEven()
        {
            while (Numbers.Count > 1)
            {
                semaphoreSlim.Wait();
                var a = Numbers.FirstOrDefault();
                if (a % 2 == 0)
                {
                    Console.WriteLine(Thread.CurrentThread.Name + " " + a);
                    Numbers.RemoveFirst();
                }
                semaphoreSlim.Release();
            }
        }

        public static void PrintOddEven()
        {
            for (int i = 1; i <= 10; i++)
            {
                Numbers.AddLast(i);
            }

            Odd = new Thread(PrintOdd);
            Even = new Thread(PrintEven);

            Odd.Name = "Odd : ";
            Even.Name = "Even :";
            Odd.Start();
            Even.Start();
            Odd.Join();
            Even.Join();
        }
    }

Now, execute the method, shown above.

public class program
{
   OddEven.PrintOddEven();
   Console.ReadKey();
}

Output

 

Odd : 1

Even : 2

Odd : 3

Even : 4

Odd : 5

Even: 6

Odd : 7

Even : 8

Odd : 9

Even : 10

Conclusion

Thus, Semaphore is a type of Non-Exclusive Synchronization lock. Semaphore is the number of free identical toilet keys.

 

Example, say we have four toilets with identical locks and keys. The semaphore count - the count of keys - is set to 4 at the beginning (all four toilets are free), then the count value is decremented as people are coming in. If all toilets are full, i.e. there are no free keys left, the semaphore count is 0. Now, when one person leaves the toilet, semaphore is increased to 1 (one free key) and is given to the next person in the queue.