Partage de technologie

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

---

En programmation simultanée, la synchronisation est une exigence de base. Le sémaphore est un mécanisme de synchronisation courant utilisé pour contrôler l'accès aux ressources partagées. En C#, les sémaphores sont implémentés via la classe Semaphore sous l'espace de noms System.Threading. Cet article présentera en détail Semaphore et ses applications en C#.

1. Qu'est-ce qu'un sémaphore ?

Un sémaphore est une valeur entière qui peut être utilisée pour contrôler l'accès à une ressource partagée. Les sémaphores sont principalement utilisés à deux fins :

Mutuellement exclusifs : Assurez-vous qu’un seul thread peut accéder aux ressources partagées en même temps.
compter: Autoriser un certain nombre de threads à accéder simultanément aux ressources partagées.
Les sémaphores sont généralement utilisés dans les scénarios suivants :

• Limitez l’accès simultané aux ressources, par exemple en limitant le nombre de connexions à la base de données.
• Synchronisation de la lecture et de l'écriture de données dans un problème producteur-consommateur.
• Synchronisez l’accès aux ressources partagées entre plusieurs processus.

2. Classe Sémaphore en C#

En C#, la classe Semaphore fournit des opérations de base sur les sémaphores. Pour créer un sémaphore, utilisez la syntaxe suivante :

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

initialCount : La valeur de comptage initiale du sémaphore, indiquant la valeur du sémaphore lors de sa création.
maximumCount : La valeur de comptage maximale du sémaphore, indiquant la valeur maximale que le sémaphore peut atteindre.

3. Exemples d'utilisation de sémaphores

3.1 Créer un sémaphore

En C#, créez un sémaphore à l'aide de la classe SemaphoreSlim. Cette classe est une implémentation de contexte de synchronisation de Semaphore, fournissant des opérations asynchrones plus flexibles.

en utilisant System.Threading;

classe publique SemaphoreExemple
{
private SemaphoreSlim semaphore = new SemaphoreSlim(3); // Crée un sémaphore de comptage pour permettre à 3 threads d'accéder en même temps

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 Utiliser des sémaphores pour synchroniser les threads

Ce qui suit est un exemple simple pour montrer comment créer, obtenir et libérer des ressources de sémaphore.

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

Dans cet exemple, nous créons un sémaphore qui permet à jusqu'à 3 threads d'exécuter la méthode Work simultanément. Chaque thread tente d'obtenir le sémaphore lors de l'appel de semaphore.WaitOne(). Si la valeur du sémaphore est supérieure à 0, le thread continuera à s'exécuter. Sinon, le thread sera bloqué jusqu'à ce qu'un autre thread libère le sémaphore.

Opérations asynchrones
La classe SemaphoreSlim fournit également des méthodes d'attente et de libération asynchrones :

1. wait semaphore.WaitAsync() : Attendre de manière asynchrone le sémaphore
2. wait semaphore.ReleaseAsync() : Libère le sémaphore de manière asynchrone

Cela rend l'utilisation des sémaphores plus flexible et mieux intégrée aux modèles de programmation asynchrone.

4. Résumé

Le sémaphore (sémaphore) en C# est un puissant mécanisme de synchronisation qui peut aider les développeurs à contrôler l'accès aux ressources partagées. En utilisant des sémaphores, nous pouvons gérer efficacement l'accès de plusieurs threads aux ressources partagées, garantissant que l'utilisation des ressources ne provoque pas de courses de données ou d'autres problèmes de synchronisation.

L'importance de Semaphore dans la programmation C# se reflète dans sa capacité à aider les développeurs à implémenter une logique de contrôle de concurrence complexe tout en maintenant la lisibilité et la maintenabilité du code. Sa facilité d'utilisation se reflète dans sa conception simple d'API et sa riche prise en charge du contexte de synchronisation.

Dans des applications pratiques, les sémaphores peuvent être utilisés pour limiter la taille du pool de connexions à la base de données, contrôler l'accès aux ressources du réseau et réaliser la synchronisation du modèle producteur-consommateur, etc. Grâce à l'introduction de cet article, nous espérons que les lecteurs pourront mieux comprendre les principes et l'utilisation de Semaphore et en profiter dans des projets réels.