C#使用SemaphoreSlim实现并发控制与限流策略的实战指南

using System;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static SemaphoreSlim semaphore = new SemaphoreSlim(3); // 最多3个并发

    static async Task Main()
    {
        var tasks = new Task[10];
        for (int i = 0; i < 10; i++)
        {
            int id = i;
            tasks[i] = Task.Run(() => DoWorkAsync(id));
        }

        await Task.WhenAll(tasks);
        Console.WriteLine("全部任务完成！");
    }

    static async Task DoWorkAsync(int id)
    {
        await semaphore.WaitAsync(); // 获取许可
        try
        {
            Console.WriteLine($"任务 {id} 开始，当前时间：{DateTime.Now:T}");
            await Task.Delay(1000); // 模拟工作
            Console.WriteLine($"任务 {id} 结束。");
        }
        finally
        {
            semaphore.Release(); // 释放许可
        }
    }
}

任务 0 开始...
任务 1 开始...
任务 2 开始...
任务 3 等待中...
任务 0 结束。
任务 3 开始...
...

using System;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

class WebCrawler
{
    static readonly HttpClient httpClient = new HttpClient();
    static readonly SemaphoreSlim semaphore = new SemaphoreSlim(5); // 最多5个并发

    static async Task Main()
    {
        var urls = new[]
        {
            "https://example.com",
            "https://dotnet.microsoft.com",
            "https://github.com",
            "https://openai.com",
            "https://google.com",
            "https://bing.com"
        };

        var tasks = new Task[urls.Length];
        for (int i = 0; i < urls.Length; i++)
        {
            string url = urls[i];
            tasks[i] = ProcessUrlAsync(url);
        }

        await Task.WhenAll(tasks);
        Console.WriteLine("所有请求完成！");
    }

    static async Task ProcessUrlAsync(string url)
    {
        await semaphore.WaitAsync();
        try
        {
            Console.WriteLine($"开始请求：{url}");
            var response = await httpClient.GetAsync(url);
            Console.WriteLine($"{url} 返回状态码：{response.StatusCode}");
        }
        finally
        {
            semaphore.Release();
        }
    }
}

using System;
using System.IO;
using System.Threading;
using System.Threading.Tasks;

class FileWriter
{
    static SemaphoreSlim semaphore = new SemaphoreSlim(1); // 一次仅允许1个线程写文件

    static async Task Main()
    {
        var tasks = new Task[5];
        for (int i = 0; i < 5; i++)
        {
            int id = i;
            tasks[i] = Task.Run(() => WriteLogAsync(id));
        }

        await Task.WhenAll(tasks);
        Console.WriteLine("写入完成。");
    }

    static async Task WriteLogAsync(int id)
    {
        await semaphore.WaitAsync();
        try
        {
            await File.AppendAllTextAsync("output.txt", $"线程 {id} 在 {DateTime.Now}\n");
            Console.WriteLine($"线程 {id} 写入完成");
        }
        finally
        {
            semaphore.Release();
        }
    }
}

if (await semaphore.WaitAsync(TimeSpan.FromSeconds(2)))
{
    try
    {
        Console.WriteLine("成功获取资源。");
    }
    finally
    {
        semaphore.Release();
    }
}
else
{
    Console.WriteLine("等待超时，放弃操作。");
}

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

class QueueProcessor
{
    static SemaphoreSlim semaphore = new SemaphoreSlim(3); // 同时处理3个任务
    static BlockingCollection<int> queue = new BlockingCollection<int>();

    static async Task Main()
    {
        // 模拟生产者
        Task.Run(() =>
        {
            for (int i = 0; i < 10; i++)
            {
                queue.Add(i);
                Console.WriteLine($"生产任务 {i}");
                Thread.Sleep(200);
            }
            queue.CompleteAdding();
        });

        // 消费者
        var consumers = new Task[3];
        for (int i = 0; i < consumers.Length; i++)
        {
            consumers[i] = Task.Run(() => ConsumeAsync(i));
        }

        await Task.WhenAll(consumers);
        Console.WriteLine("队列处理完成。");
    }

    static async Task ConsumeAsync(int workerId)
    {
        foreach (var item in queue.GetConsumingEnumerable())
        {
            await semaphore.WaitAsync();
            try
            {
                Console.WriteLine($"工作线程 {workerId} 处理任务 {item}");
                await Task.Delay(500);
            }
            finally
            {
                semaphore.Release();
            }
        }
    }
}