Using the SemaphoreSlim construct

This recipe will show you how to limit multithreaded access to some resources with the help of the SemaphoreSlim construct. SemaphoreSlim is a lightweight version of Semaphore; it limits the number of threads that can access a resource concurrently.

Getting ready

To step through this recipe, you will need Visual Studio 2015. There are no other prerequisites. The source code for this recipe can be found at BookSamples\Chapter2\Recipe3.

How to do it...

To understand how to limit a multithreaded access to a resource with the help of the SemaphoreSlim construct, perform the following steps:

1. Start Visual Studio 2015. Create a new C# console application project.
2. In the Program.cs file, add the following using directives:

   using System;
   using System.Threading;
   using static System.Console;
   using static System.Threading.Thread;

3. Below the Main method, add the following code snippet:

   static SemaphoreSlim _semaphore = new SemaphoreSlim(4);
   
   static void AccessDatabase(string name, int seconds)
   {
     WriteLine($"{name} waits to access a database");
     _semaphore.Wait();
     WriteLine($"{name} was granted an access to a database");
     Sleep(TimeSpan.FromSeconds(seconds));
     WriteLine($"{name} is completed");
     _semaphore.Release();
   }

4. Inside the Main method, add the following code snippet:

   for (int i = 1; i <= 6; i++)
   {
     string threadName = "Thread " + i;
     int secondsToWait = 2 + 2 * i;
     var t = new Thread(() => AccessDatabase(threadName, secondsToWait));
     t.Start();
   }

5. Run the program.

How it works...

When the main program starts, it creates a SemaphoreSlim instance, specifying the number of concurrent threads allowed in its constructor. Then, it starts six threads with different names and start times to run.

Every thread tries to acquire access to a database, but we restrict the number of concurrent accesses to a database to four threads with the help of a semaphore. When four threads get access to a database, the other two threads wait until one of the previous threads finishes its work and signals to other threads by calling the _semaphore.Release method.

There's more…

Here, we use a hybrid construct, which allows us to save a context switch in cases where the wait time is very short. However, there is an older version of this construct called Semaphore. This version is a pure, kernel-time construct. There is no sense in using it, except in one very important scenario; we can create a named semaphore like a named mutex and use it to synchronize threads in different programs. SemaphoreSlim does not use Windows kernel semaphores and does not support interprocess synchronization, so use Semaphore in this case.