// 危險的反模式：瞬間發(fā)起1000個HTTP請求
public async Task ProcessOrdersDangerously(List<Order> orders)
{
    var tasks = orders.Select(order => CallPaymentApiAsync(order));
    await Task.WhenAll(tasks); // 瞬間并發(fā)過高！
}

// 錯誤：Parallel.ForEach用于CPU密集型同步操作
Parallel.ForEach(orders, async order => 
{
    await CallPaymentApiAsync(order); // 實際上同步執(zhí)行
});

// 次優(yōu)方案：雖能限制并發(fā)，但效率低下
for (int i = 0; i < orders.Count; i += 10)
{
    var batch = orders.Skip(i).Take(10);
    await Task.WhenAll(batch.Select(CallPaymentApiAsync));
    await Task.Delay(100); // 人工延遲降低效率
}

public class AsyncConcurrencyController
{
    // 初始化信號量，設(shè)置最大并發(fā)數(shù)為5
    private static readonly SemaphoreSlim _semaphore = new SemaphoreSlim(5, 5);
    
    public async Task ProcessWithConcurrencyControl(List<Item> items)
    {
        var tasks = items.Select(async item =>
        {
            // 關(guān)鍵：異步等待信號量，不阻塞線程
            await _semaphore.WaitAsync();
            try
            {
                // 執(zhí)行受保護的異步操作
                await ProcessItemAsync(item);
            }
            finally
            {
                // 關(guān)鍵：必須釋放信號量
                _semaphore.Release();
            }
        });
        
        await Task.WhenAll(tasks);
    }
}

初始狀態(tài): [√][√][√][√][√] [ ][ ][ ][ ][ ] ... (20個任務(wù))
          ↑ 5個并發(fā)槽可用

執(zhí)行過程:
1. 任務(wù)1-5立即獲取信號量并執(zhí)行
2. 任務(wù)6-20在WaitAsync()處等待
3. 任務(wù)1完成后釋放信號量
4. 任務(wù)6立即獲取釋放的信號量并開始執(zhí)行
5. 如此循環(huán)，始終保持最多5個并發(fā)

public class ConcurrentExecutor
{
    private readonly SemaphoreSlim _semaphore;
    
    public ConcurrentExecutor(int maxConcurrency)
    {
        _semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
    }
    
    public async Task<TResult> ExecuteAsync<TResult>(
        Func<Task<TResult>> operation, 
        CancellationToken cancellationToken = default)
    {
        await _semaphore.WaitAsync(cancellationToken);
        try
        {
            return await operation();
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

public async Task<T> ExecuteWithTimeoutAsync<T>(
    Func<Task<T>> operation,
    TimeSpan timeout,
    CancellationToken cancellationToken = default)
{
    // 嘗試在指定時間內(nèi)獲取信號量
    bool acquired = await _semaphore.WaitAsync(timeout, cancellationToken);
    
    if (!acquired)
        throw new TimeoutException($"無法在{timeout.TotalSeconds}秒內(nèi)獲取執(zhí)行許可");
    
    try
    {
        return await operation();
    }
    finally
    {
        _semaphore.Release();
    }
}

public async Task ProcessBatchWithProgressAsync<T>(
    IEnumerable<T> items,
    Func<T, Task> processor,
    int maxConcurrency,
    IProgress<int> progress = null,
    CancellationToken cancellationToken = default)
{
    var semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
    int total = items.Count();
    int completed = 0;
    
    var tasks = items.Select(async item =>
    {
        await semaphore.WaitAsync(cancellationToken);
        try
        {
            await processor(item);
        }
        finally
        {
            semaphore.Release();
            Interlocked.Increment(ref completed);
            progress?.Report((completed * 100) / total);
        }
    });
    
    await Task.WhenAll(tasks);
}

// 場景：每個用戶最多5個并發(fā)，全局最多50個并發(fā)
public class TieredConcurrencyController
{
    private readonly SemaphoreSlim _globalSemaphore = new(50, 50);
    private readonly ConcurrentDictionary<string, SemaphoreSlim> _userSemaphores = new();
    
    public async Task ExecuteForUserAsync(string userId, Func<Task> operation)
    {
        // 獲取用戶級信號量（每個用戶獨立）
        var userSemaphore = _userSemaphores.GetOrAdd(userId, _ => new SemaphoreSlim(5, 5));
        
        // 先獲取全局許可
        await _globalSemaphore.WaitAsync();
        await userSemaphore.WaitAsync();
        
        try
        {
            await operation();
        }
        finally
        {
            userSemaphore.Release();
            _globalSemaphore.Release();
        }
    }
}

public class ResilientConcurrentExecutor
{
    private readonly SemaphoreSlim _semaphore;
    private readonly AsyncPolicy _retryPolicy;
    
    public async Task<T> ExecuteWithRetryAsync<T>(
        Func<Task<T>> operation, 
        int maxConcurrency)
    {
        _semaphore = new SemaphoreSlim(maxConcurrency, maxConcurrency);
        _retryPolicy = Policy
            .Handle<HttpRequestException>()
            .WaitAndRetryAsync(3, retryAttempt => 
                TimeSpan.FromSeconds(Math.Pow(2, retryAttempt)));
        
        await _semaphore.WaitAsync();
        try
        {
            return await _retryPolicy.ExecuteAsync(operation);
        }
        finally
        {
            _semaphore.Release();
        }
    }
}

public class AdaptiveConcurrencyController
{
    private SemaphoreSlim _semaphore;
    private readonly int _initialConcurrency;
    private readonly object _lock = new object();
    
    public void AdjustConcurrencyBasedOnMetrics(
        double successRate, 
        double avgLatency, 
        int errorCount)
    {
        lock (_lock)
        {
            int newLimit = CalculateOptimalConcurrency(
                successRate, avgLatency, errorCount);
            
            if (newLimit != _semaphore.CurrentCount)
            {
                var oldSemaphore = _semaphore;
                _semaphore = new SemaphoreSlim(newLimit, newLimit);
                
                // 遷移正在等待的任務(wù)到新信號量
                MigrateWaiters(oldSemaphore, _semaphore);
            }
        }
    }
}

public class MonitoredSemaphoreSlim : SemaphoreSlim
{
    public int CurrentWaitCount { get; private set; }
    public TimeSpan AverageWaitTime { get; private set; }
    
    public new async Task WaitAsync(CancellationToken cancellationToken)
    {
        var stopwatch = Stopwatch.StartNew();
        CurrentWaitCount++;
        
        try
        {
            await base.WaitAsync(cancellationToken);
        }
        finally
        {
            stopwatch.Stop();
            CurrentWaitCount--;
            UpdateAverageWaitTime(stopwatch.Elapsed);
        }
    }
}