Technology Sharing

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

---

In concurrent programming, synchronization is a basic requirement. Semaphore is a common synchronization mechanism, which is used to control access to shared resources. In C#, semaphores are implemented through the Semaphore class under the System.Threading namespace. This article will introduce Semaphore in C# and its application in detail.

1. What is a semaphore?

A semaphore is an integer value that can be used to control access to a shared resource. Semaphores are used for two main purposes:

Mutually exclusive: Ensure that only one thread can access shared resources at the same time.
count: Allows a certain number of threads to access shared resources simultaneously.
Semaphores are commonly used in the following scenarios:

• Limit concurrent access to resources, such as limiting the number of database connections.
• Synchronize the reading and writing of data in the producer-consumer problem.
• Synchronize access to shared resources among multiple processes.

2. Semaphore class in C#

In C#, the Semaphore class provides the basic operations of semaphores. To create a semaphore, you can use the following syntax:

Semaphore semaphore = new Semaphore(initialCount, maximumCount);
1

initialCount: The initial count value of the semaphore, which indicates the value of the semaphore when it is created.
maximumCount: The maximum count value of the semaphore, indicating the maximum value that the semaphore can reach.

3. Examples of using semaphores

3.1 Creating a Semaphore

In C#, semaphores are created using the SemaphoreSlim class, which is a synchronization context implementation of Semaphore and provides more flexible asynchronous operations.

using System.Threading;

public class SemaphoreExample
{
private SemaphoreSlim semaphore = new SemaphoreSlim(3); // Create a counting semaphore that allows 3 threads to access it simultaneously

public void DoWork()
{
    semaphore.Wait(); // 获取信号量，如果信号量小于0，线程将被阻塞

    try
    {
        // 执行共享资源的操作
    }
    finally
    {
        semaphore.Release(); // 释放信号量
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13

}

3.2 Using semaphores to synchronize threads

The following is a simple example to demonstrate how to create, acquire, and release semaphore resources.

using System;
using System.Threading;

class Program
{
    static void Main()
    {
        // 创建信号量，允许3个线程同时访问共享资源
        Semaphore semaphore = new Semaphore(3, 3);

        // 创建和启动线程
        for (int i = 0; i < 10; i++)
        {
            new Thread(() => Work(semaphore)).Start();
        }
    }

    static void Work(Semaphore semaphore)
    {
        try
        {
            // 获取信号量
            semaphore.WaitOne();

            // 执行共享资源的操作
            Console.WriteLine($"线程 {Thread.CurrentThread.ManagedThreadId} 正在执行。");
            Thread.Sleep(1000);
        }
        finally
        {
            // 释放信号量
            semaphore.Release();
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

In this example, we create a semaphore that allows up to 3 threads to execute the Work method simultaneously. Each thread will try to acquire the semaphore when calling semaphore.WaitOne(). If the value of the semaphore is greater than 0, the thread will continue to execute. Otherwise, the thread will be blocked until another thread releases the semaphore.

Asynchronous Operations
The SemaphoreSlim class also provides asynchronous waiting and release methods:

1. await semaphore.WaitAsync(): Asynchronously wait for the semaphore
2. await semaphore.ReleaseAsync(): asynchronously release the semaphore

This makes the use of semaphores more flexible and better integrated with asynchronous programming models.

4. Conclusion

Semaphore in C# is a powerful synchronization mechanism that helps developers control access to shared resources. By using semaphores, we can effectively manage access to shared resources by multiple threads and ensure that the use of resources does not cause data competition or other synchronization issues.

The importance of Semaphore in C# programming is reflected in its ability to help developers implement complex concurrency control logic while maintaining code readability and maintainability. Its ease of use is reflected in its simple API design and rich synchronization context support.

In practical applications, semaphores can be used to limit the size of database connection pools, control access to network resources, and achieve synchronization of producer-consumer models. Through the introduction of this article, we hope that readers can better understand the principles and usage of Semaphore and give full play to its advantages in practical projects.