Condivisione della tecnologia

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

---

Nella programmazione concorrente la sincronizzazione è un requisito fondamentale. Il semaforo è un meccanismo di sincronizzazione comune utilizzato per controllare l'accesso alle risorse condivise. In C# i semafori vengono implementati tramite la classe Semaphore nello spazio dei nomi System.Threading. Questo articolo introdurrà in dettaglio Semaphore e le sue applicazioni in C#.

1. Cos'è un semaforo?

Un semaforo è un valore intero che può essere utilizzato per controllare l'accesso a una risorsa condivisa. I semafori vengono utilizzati principalmente per due scopi:

Mutuamente esclusivi: Assicurarsi che solo un thread possa accedere alle risorse condivise allo stesso tempo.
contare: Consentire a un certo numero di thread di accedere simultaneamente alle risorse condivise.
I semafori vengono solitamente utilizzati nei seguenti scenari:

• Limitare l'accesso simultaneo alle risorse, ad esempio limitando il numero di connessioni al database.
• Sincronizzazione della lettura e della scrittura dei dati in un problema produttore-consumatore.
• Sincronizza l'accesso alle risorse condivise tra più processi.

2. Classe semaforo in C#

In C# la classe Semaphore fornisce operazioni di base sui semafori. Per creare un semaforo, utilizzare la seguente sintassi:

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

partialCount: il valore di conteggio iniziale del semaforo, che indica il valore del semaforo al momento della creazione.
maximCount: il valore di conteggio massimo del semaforo, che indica il valore massimo che il semaforo può raggiungere.

3. Esempi di utilizzo dei semafori

3.1 Creare un semaforo

In C# creare un semaforo utilizzando la classe SemaphoreSlim. Questa classe è un'implementazione del contesto di sincronizzazione di Semaphore, che fornisce operazioni asincrone più flessibili.

utilizzando System.Threading;

classe pubblica SemaphoreExample
{
private SemaphoreSlim semaforo = new SemaphoreSlim(3); // Crea un semaforo di conteggio per consentire a 3 thread di accedere contemporaneamente

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 Utilizzare i semafori per sincronizzare i thread

Di seguito è riportato un semplice esempio per dimostrare come creare, ottenere e rilasciare risorse semaforo.

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 questo esempio creiamo un semaforo che consente a un massimo di 3 thread di eseguire il metodo Work contemporaneamente. Ogni thread tenta di ottenere il semaforo quando chiama semaphore.WaitOne(). Se il valore del semaforo è maggiore di 0, il thread continuerà l'esecuzione. Altrimenti, il thread verrà bloccato finché un altro thread non rilascerà il semaforo.

Operazioni asincrone
La classe SemaphoreSlim fornisce anche metodi di attesa e rilascio asincroni:

1. attendono semaforo.WaitAsync(): attende in modo asincrono il semaforo
2. attendono semaforo.ReleaseAsync(): rilascia il semaforo in modo asincrono

Ciò rende l'uso dei semafori più flessibile e meglio integrato con i modelli di programmazione asincrona.

4. Riepilogo

Il semaforo (semaforo) in C# è un potente meccanismo di sincronizzazione che può aiutare gli sviluppatori a controllare l'accesso alle risorse condivise. Utilizzando i semafori, possiamo gestire in modo efficace l'accesso di più thread alle risorse condivise, garantendo che l'utilizzo delle risorse non causi corse di dati o altri problemi di sincronizzazione.

L'importanza di Semaphore nella programmazione C# si riflette nella sua capacità di aiutare gli sviluppatori a implementare complesse logiche di controllo della concorrenza mantenendo la leggibilità e la manutenibilità del codice. La sua facilità d'uso si riflette nella sua semplice progettazione API e nel ricco supporto del contesto di sincronizzazione.

Nelle applicazioni pratiche, i semafori possono essere utilizzati per limitare la dimensione del pool di connessioni del database, controllare l'accesso alle risorse di rete e ottenere la sincronizzazione del modello produttore-consumatore, ecc. Attraverso l'introduzione di questo articolo, speriamo che i lettori possano comprendere meglio i principi e l'utilizzo di Semaphore e trarne vantaggio in progetti reali.