Compartilhamento de tecnologia

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

---

Na programação simultânea, a sincronização é um requisito básico. Semáforo é um mecanismo de sincronização comum usado para controlar o acesso a recursos compartilhados. Em C#, os semáforos são implementados por meio da classe Semaphore no namespace System.Threading. Este artigo apresentará detalhadamente o Semaphore e suas aplicações em C#.

1. O que é um semáforo?

Um semáforo é um valor inteiro que pode ser usado para controlar o acesso a um recurso compartilhado. Os semáforos são usados ​​principalmente para dois propósitos:

Mutualmente exclusivo: Certifique-se de que apenas um thread possa acessar recursos compartilhados ao mesmo tempo.
contar: Permitir que um certo número de threads acesse recursos compartilhados simultaneamente.
Os semáforos são geralmente usados ​​nos seguintes cenários:

• Limite o acesso simultâneo aos recursos, como limitar o número de conexões de banco de dados.
• Sincronizando a leitura e escrita de dados em um problema produtor-consumidor.
• Sincronize o acesso a recursos compartilhados entre vários processos.

2. Classe semáforo em C#

Em C#, a classe Semaphore fornece operações básicas em semáforos. Para criar um semáforo, use a seguinte sintaxe:

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

inicialCount: O valor de contagem inicial do semáforo, indicando o valor do semáforo quando foi criado.
MaximumCount: O valor máximo de contagem do semáforo, indicando o valor máximo que o semáforo pode atingir.

3. Exemplos de uso de semáforos

3.1 Crie um semáforo

Em C#, crie um semáforo usando a classe SemaphoreSlim. Esta classe é uma implementação de contexto de sincronização do Semaphore, fornecendo operações assíncronas mais flexíveis.

usando System.Threading;

classe pública SemaphoreExample
{
private SemaphoreSlim semáforo = new SemaphoreSlim(3); // Cria um semáforo de contagem para permitir o acesso de 3 threads ao mesmo tempo

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 Use semáforos para sincronizar threads

A seguir está um exemplo simples para demonstrar como criar, obter e liberar recursos de semáforo.

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

Neste exemplo, criamos um semáforo que permite que até 3 threads executem o método Work simultaneamente. Cada thread tenta adquirir o semáforo ao chamar semáforo.WaitOne(). Se o valor do semáforo for maior que 0, a thread continuará em execução. Caso contrário, o thread será bloqueado até que outro thread libere o semáforo.

Operações assíncronas
A classe SemaphoreSlim também fornece métodos assíncronos de espera e liberação:

1. aguardar semáforo.WaitAsync(): aguardar de forma assíncrona pelo semáforo
2. await semaphore.ReleaseAsync(): libera o semáforo de forma assíncrona

Isso torna o uso de semáforos mais flexível e melhor integrado aos modelos de programação assíncrona.

4. Resumo

Semáforo (semáforo) em C# é um poderoso mecanismo de sincronização que pode ajudar os desenvolvedores a controlar o acesso a recursos compartilhados. Ao usar semáforos, podemos gerenciar com eficácia o acesso de vários threads a recursos compartilhados, garantindo que o uso de recursos não cause corridas de dados ou outros problemas de sincronização.

A importância do Semaphore na programação C# se reflete em sua capacidade de ajudar os desenvolvedores a implementar lógica complexa de controle de simultaneidade, mantendo a legibilidade e a manutenção do código. Sua facilidade de uso se reflete no design simples da API e no rico suporte ao contexto de sincronização.

Em aplicações práticas, os semáforos podem ser usados ​​para limitar o tamanho do conjunto de conexões de banco de dados, controlar o acesso aos recursos da rede e obter a sincronização do modelo produtor-consumidor, etc. Através da introdução deste artigo, esperamos que os leitores possam compreender melhor os princípios e o uso do Semaphore e tirar proveito dele em projetos reais.