C#信号量深度解析：从原理到高并发实战指南

一、信号量核心机制解析

1. 基础概念三维度

信号量（Semaphore）是一种基于计数器的线程同步原语，其核心机制包含：

• ​计数控制：维护可用资源数（如数据库连接数），初始值决定启动时并发量，最大值设定系统承载上限
• ​等待队列：当资源耗尽时，新请求线程进入阻塞状态并按FIFO原则排队
• ​原子操作：通过WaitOne()和Release()实现计数器增减的线程安全操作

2. 运行流程图解

线程A → WaitOne() → 计数器-1 → 资源可用 → 执行任务
线程B → WaitOne() → 计数器=0 → 进入阻塞队列
线程A → Release() → 计数器+1 → 唤醒线程B

二、C#信号量双雄对比

实测数据：在1000并发请求下，SemaphoreSlim吞吐量比Semaphore高8-10倍

三、基础应用场景实战

1. 数据库连接池控制

public class DbConnectionPool
{
    private SemaphoreSlim _pool = new SemaphoreSlim(10, 10);
    private ConcurrentQueue<SqlConnection> _connections = new ConcurrentQueue<SqlConnection>();

    public async Task<SqlConnection> GetConnectionAsync()
    {
        await _pool.WaitAsync();
        if (_connections.TryDequeue(out var conn)) 
            return conn;
        return new SqlConnection("ConnectionString");
    }

    public void ReleaseConnection(SqlConnection conn)
    {
        _connections.Enqueue(conn);
        _pool.Release();
    }
}

关键点：通过信号量控制物理连接数，配合对象池减少创建开销

2. 生产者-消费者模型

class MessageQueue
{
    private SemaphoreSlim _messageSignal = new SemaphoreSlim(0, int.MaxValue);
    private ConcurrentQueue<string> _queue = new ConcurrentQueue<string>();

    public void Enqueue(string message)
    {
        _queue.Enqueue(message);
        _messageSignal.Release();  // 唤醒消费者
    }

    public async Task<string> DequeueAsync()
    {
        await _messageSignal.WaitAsync();
        _queue.TryDequeue(out var msg);
        return msg;
    }
}

优势：解耦生产消费速率，避免线程忙等待

四、高级应用技巧

1. 动态扩容策略

public class ElasticSemaphore
{
    private SemaphoreSlim _semaphore;
    private int _currentMax;

    public ElasticSemaphore(int initial) => Reset(initial);

    public void Reset(int newMax)
    {
        int delta = newMax - _currentMax;
        if(delta > 0) _semaphore.Release(delta);
        _currentMax = newMax;
    }
}

应用场景：电商大促期间临时扩容服务线程数

2. 分布式锁实现

public class RedisSemaphore
{
    private readonly IDatabase _redis;
    private string _key;
    
    public async Task<bool> AcquireAsync(TimeSpan timeout)
    {
        var result = await _redis.StringSetAsync(_key, 1, timeout, When.NotExists);
        return result;
    }

    public async Task ReleaseAsync() => await _redis.KeyDeleteAsync(_key);
}

注意事项：需配合续期机制防止死锁，推荐使用RedLock算法

五、性能优化实践

1. 基准测试对比

测试环境：.NET 6 + Intel i9-12900K

2. 最佳实践原则

1. ​容量规划：最大并发数= (核心数×2) + 磁盘IO密集型系数
2. ​异常防御：使用try-finally确保Release()必执行
3. ​监控集成：暴露AvailableWaitHandle属性到APM系统
4. ​死锁预防：设置合理超时时间（推荐100ms-5s）

六、特殊场景解决方案

1. 优先级队列实现

class PrioritySemaphore
{
    private SortedList<int, SemaphoreSlim> _priorityQueues = new();

    public async Task AcquireAsync(int priority)
    {
        var semaphore = _priorityQueues.GetOrAdd(priority, _ => new SemaphoreSlim(0));
        await semaphore.WaitAsync();
    }

    public void Release(int priority)
    {
        if(_priorityQueues.TryGetValue(priority, out var sem))
            sem.Release();
    }
}

应用案例：VIP用户请求优先处理

2. 异步信号量模式

async Task ProcessRequestAsync()
{
    var semaphore = new SemaphoreSlim(10);
    var tasks = Enumerable.Range(0, 1000).Select(async i => {
        await semaphore.WaitAsync();
        try {
            await HandleAsync(i);
        } finally {
            semaphore.Release();
        }
    });
    await Task.WhenAll(tasks);
}

优势：完美集成async/await编程模型