{"id":876,"date":"2023-03-11T10:32:44","date_gmt":"2023-03-11T03:32:44","guid":{"rendered":"https:\/\/csharptutorial.net\/?page_id=876"},"modified":"2023-03-11T11:45:20","modified_gmt":"2023-03-11T04:45:20","slug":"csharp-semaphoreslim","status":"publish","type":"page","link":"https:\/\/www.csharptutorial.net\/csharp-concurrency\/csharp-semaphoreslim\/","title":{"rendered":"C# SemaphoreSlim"},"content":{"rendered":"\n

Summary<\/strong>: in this tutorial, you’ll learn how to use the C# SemaphoreSlim<\/code> to limit the number of threads that can access a shared resource concurrently.<\/p>\n\n\n\n

Introduction to the C# SemaphoreSlim class<\/h2>\n\n\n\n

A semaphore is a mechanism to limit the number of threads<\/a> that can access a shared resource simultaneously.<\/p>\n\n\n\n

The semaphore concept is based on a counter that specifies the number of available resources. <\/p>\n\n\n\n

To access the shared resource, a thread needs to request a permit from the semaphore.<\/p>\n\n\n\n

If the permit is available, the semaphore will decrement the counter. However, if the counter is zero, the semaphore will block until a permit becomes available.<\/p>\n\n\n\n

Once the thread completes processing the shared resource, it needs to release the permit back to the semaphore so that other threads can get the permit. When the thread releases the permit, the semaphore increments the counter<\/p>\n\n\n\n

C# has two classes that implement the semaphore concept: Semaphore<\/code> and SemaphoreSlim<\/code>.<\/p>\n\n\n\n

The Semaphore<\/code> class has been available since the early version of the .NET Framework. The SemaphoreSlim<\/code> is the more recent class introduced in .NET Framework 4.0<\/code> and .NET core. <\/p>\n\n\n\n

The SemaphoreSlim<\/code><\/code> class is a lightweight implementation of the Semaphore<\/code> class. The SemaphoreSlim<\/code><\/code> is faster and more memory efficient than the Semaphore<\/code> class.<\/p>\n\n\n\n

How to use the SemaphoreSlim class<\/h2>\n\n\n\n

To use the SemaphoreSlim<\/code> class, you follow these steps:<\/p>\n\n\n\n

First, create a SemaphoreSlim<\/code> object and pass the initial number of permits to its constructor:<\/p>\n\n\n

SemaphoreSlim semaphore = new<\/span>(3<\/span>);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
In this example, the semaphore object has an initial counter of 3. It means that up to three threads are allowed to access shared resources concurrently.<\/p>\n\n\n\n
Second, call the WaitAsync()<\/code> method of the semaphore object to request a permit:<\/p>\n\n\n
await<\/span> semaphore.WaitAsync();<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The WaitAsync()<\/code> method returns a Task<\/code> object that waits for the permit to be granted.<\/p>\n\n\n\n
Third, call the Release()<\/code> method of semaphore object to release the permit once you completed accessing the shared resource:<\/p>\n\n\n
semaphore.Release();<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
await<\/span> semaphore.WaitAsync();\n\ntry<\/span>\n{\n    \/\/ Access the shared resource<\/span>\n}\nfinally<\/span>\n{\n    semaphore.Release();\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The following example demonstrates how to use the SemaphoreSlim<\/code> class to allow a limited number of tasks can access the shared resource simultaneously:<\/p>\n\n\n
using<\/span> static<\/span> System.Console; \n\nSemaphoreSlim semaphore = new<\/span>(3<\/span>);\nint<\/span> amount = 0<\/span>;\n\nasync<\/span> Task AccessAsync<\/span>(int<\/span> id<\/span>)<\/span>\n{\n    WriteLine($\"Task {id}<\/span> is waiting to access the amount.\"<\/span>);\n    await<\/span> semaphore.WaitAsync();\n\n    try<\/span>\n    {\n        WriteLine($\"Task {id}<\/span> is now accessing the amount.\"<\/span>);\n\n\n        \/\/ simulate some work<\/span>\n        await<\/span> Task.Delay(TimeSpan.FromSeconds(1<\/span>));\n        \n        \/\/ increase the counter<\/span>\n        Interlocked.Increment(ref<\/span> amount);\n\n\n        \/\/ completed the work<\/span>\n        WriteLine($\"Task {id}<\/span> has completed accessing the amount {amount}<\/span>\"<\/span>);\n    }\n    finally<\/span>\n    {\n        semaphore.Release();\n    }\n}\n\n\n\/\/ start 10 tasks to access the amount concurrently<\/span>\nvar<\/span>  tasks = new<\/span> List<Task>();\n\nfor<\/span> (int<\/span> i = 1<\/span>; i <= 10<\/span>; i++)\n{\n    tasks.Add(AccessAsync(i));\n}\n\n\/\/ wait for all task to complete<\/span>\nawait<\/span> Task.WhenAll(tasks);\n\nWriteLine(\"All tasks completed.\"<\/span>);\nReadLine();<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
How it works.<\/p>\n\n\n\n
First, create a SemaphoreSlim<\/code> object that allows up to three tasks to access the shared resource at the same time:<\/p>\n\n\n
SemaphoreSlim semaphore = new<\/span>(3<\/span>);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Next, declare the amount<\/code> variable that acts as a shared resource:<\/p>\n\n\n
int<\/span> amount = 0<\/span>;<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
async<\/span> Task AccessAsync<\/span>(int<\/span> id<\/span>)<\/span>\n{\n    WriteLine($\"Task {id}<\/span> is waiting to access the amount.\"<\/span>);\n    await<\/span> semaphore.WaitAsync();\n\n    try<\/span>\n    {\n        WriteLine($\"Task {id}<\/span> is now accessing the amount.\"<\/span>);\n\n\n        \/\/ simulate some work<\/span>\n        await<\/span> Task.Delay(TimeSpan.FromSeconds(1<\/span>));\n        \n        \/\/ increase the counter<\/span>\n        Interlocked.Increment(ref<\/span> amount);\n\n\n        \/\/ completed the work<\/span>\n        WriteLine($\"Task {id}<\/span> has completed accessing the amount {amount}<\/span>\"<\/span>);\n    }\n    finally<\/span>\n    {\n        semaphore.Release();\n    }\n}<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The AccessAsync()<\/code> method simulates accessing the shared variable amount<\/code> using the semaphore object.<\/p>\n\n\n\n
The AccessAsync()<\/code> method also writes some messages to the console to indicate the start and end of the task.<\/p>\n\n\n\n
After that, create ten tasks that execute the AccessAsync<\/code> method and wait for them to complete using the Task.WhenAll<\/code>()<\/code> method:<\/p>\n\n\n
\/\/ start 10 tasks to access the amount concurrently<\/span>\nvar<\/span>  tasks = new<\/span> List<Task>();\n\nfor<\/span> (int<\/span> i = 1<\/span>; i <= 10<\/span>; i++)\n{\n    tasks.Add(AccessAsync(i));\n}\n\n\/\/ wait for all task to complete<\/span>\nawait<\/span> Task.WhenAll(tasks);<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
Finally, write a message to the console to notify the completion of all the tasks and wait for the user to press a key before terminating the program:<\/p>\n\n\n
WriteLine(\"All tasks completed.\"<\/span>);\nReadLine();<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The following shows the output of the program:<\/p>\n\n\n
Task 1<\/span> is<\/span> waiting to access the amount.\nTask 1<\/span> is<\/span> now accessing the amount.\nTask 2<\/span> is<\/span> waiting to access the amount.\nTask 2<\/span> is<\/span> now accessing the amount.\nTask 3<\/span> is<\/span> waiting to access the amount.\nTask 3<\/span> is<\/span> now accessing the amount.\nTask 4<\/span> is<\/span> waiting to access the amount.\nTask 5<\/span> is<\/span> waiting to access the amount.\nTask 6<\/span> is<\/span> waiting to access the amount.\nTask 7<\/span> is<\/span> waiting to access the amount.\nTask 8<\/span> is<\/span> waiting to access the amount.\nTask 9<\/span> is<\/span> waiting to access the amount.\nTask 10<\/span> is<\/span> waiting to access the amount.\nTask 1<\/span> has completed accessing the amount 1<\/span>\nTask 3<\/span> has completed accessing the amount 2<\/span>\nTask 5<\/span> is<\/span> now accessing the amount.\nTask 4<\/span> is<\/span> now accessing the amount.\nTask 2<\/span> has completed accessing the amount 3<\/span>\nTask 6<\/span> is<\/span> now accessing the amount.\nTask 5<\/span> has completed accessing the amount 6<\/span>\nTask 6<\/span> has completed accessing the amount 6<\/span>\nTask 8<\/span> is<\/span> now accessing the amount.\nTask 7<\/span> is<\/span> now accessing the amount.\nTask 4<\/span> has completed accessing the amount 6<\/span>\nTask 9<\/span> is<\/span> now accessing the amount.\nTask 9<\/span> has completed accessing the amount 7<\/span>\nTask 8<\/span> has completed accessing the amount 8<\/span>\nTask 7<\/span> has completed accessing the amount 9<\/span>\nTask 10<\/span> is<\/span> now accessing the amount.\nTask 10<\/span> has completed accessing the amount 10<\/span>\nAll tasks completed.<\/code><\/span>Code language:<\/span> C#<\/span> (<\/span>cs<\/span>)<\/span><\/small><\/pre>\n\n\n
The output shows that:<\/p>\n\n\n\n
The AccessAsync()<\/code> method call WaitAsync()<\/code> of the semaphore object to wait for a permit available, increments the amount<\/code> variable using the Increment()<\/code> method of the Interlocked<\/a><\/code> class, and returns the permit back to the semaphore using the Release()<\/code> method of the semaphore object. <\/p>\n\n\n\n
Then, define an asynchronous method<\/a> AccessAsync<\/code> that takes an integer parameter id<\/code>:<\/p>\n\n\n
It’s a good practice to use the try...finally<\/a><\/code> block to ensure that the Release()<\/code> method is always called even if an exception is raised while accessing the shared resource:<\/p>\n\n\n