引言

在 C# 开发中，合理控制并发任务数量是确保应用程序高效、稳定运行的关键。过多的并发任务可能会耗尽系统资源，导致性能下降和不稳定。本文将深入探讨几种有效的方法来限制 C# 中的并发任务数量，并通过具体的应用场景和示例代码展示如何实现这些方法。

使用 SemaphoreSlim

SemaphoreSlim 是一个轻量级的同步原语，用于控制访问某一资源或资源池的线程数。通过它，我们可以很容易地限制并发任务的数量。当你有一个需要访问共享资源（如数据库连接池）的任务列表，但希望同时执行的任务数量不超过某个特定值时，可以使用SemaphoreSlim。

示例

using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        int maxConcurrentTasks = 3;
        SemaphoreSlim semaphore = new SemaphoreSlim(maxConcurrentTasks);
        List<Task> tasks = new List<Task>();
        for (int i = 0; i < 100; i++)
        {
            await semaphore.WaitAsync();
            var task = Task.Run(async () =>
            {
                try
                {
                    // 模拟长时间运行的任务
                    Console.WriteLine($"Task {Task.CurrentId} started.");
                    await Task.Delay(TimeSpan.FromSeconds(2));
                    Console.WriteLine($"Task {Task.CurrentId} completed.");
                }
                finally
                {
                    semaphore.Release();
                }
            });
            tasks.Add(task);
        }
        await Task.WhenAll(tasks);
        Console.WriteLine("All tasks completed.");
    }
}

在这个示例中，我们限制了最多只有 3 个任务可以同时运行。通过对SemaphoreSlim 的调用，我们确保了当达到最大并发任务数量时，其他任务将会等待直到某个任务完成并释放信号量。

使用 TPL Dataflow

TPL (Task Parallel Library) Dataflow 提供了一个更高级的方式来处理数据流和并发任务，通过它可以很容易地限制并发任务的数量。当你需要处理一系列的数据或任务，并且每个任务都可能需要一些时间来完成，同时你想要限制同时处理这些任务的数量时，可以使用 TPL Dataflow。

示例

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

class Program
{
    static async Task Main(string[] args)
    {
        var options = new ExecutionDataflowBlockOptions
        {
            MaxDegreeOfParallelism = 3 // 最大并发任务数量
        };
        var block = new ActionBlock<int>(async n =>
        {
            Console.WriteLine($"Processing {n}...");
            await Task.Delay(TimeSpan.FromSeconds(1)); // 模拟异步操作
            Console.WriteLine($"Processed {n}.");
        }, options);
        for (int i = 0; i < 100; i++)
        {
            block.Post(i);
        }
        block.Complete();
        await block.Completion;
        Console.WriteLine("All tasks completed.");
    }
}

在这个示例中，ActionBlock 被用来处理一系列的任务，通过设置ExecutionDataflowBlockOptions 中的MaxDegreeOfParallelism 属性，我们限制了最大的并发任务数量。

使用 Parallel.ForEach

Parallel.ForEach 是 .NET 中用于并行处理集合元素的方法，它可以指定MaxDegreeOfParallelism 参数来限制并发任务的数量。

示例

using System;
using System.Collections.Generic;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        var urls = new List<string> { /* 一系列 URL */ };
        var options = new ParallelOptions { MaxDegreeOfParallelism = 3 };
        await Parallel.ForEachAsync(urls, options, async (url, _) =>
        {
            var html = await new HttpClient().GetStringAsync(url);
            Console.WriteLine($"retrieved {html.Length} characters from {url}");
        });
    }
}

在这个示例中，我们使用Parallel.ForEachAsync 方法来并行下载多个网页内容，并通过设置MaxDegreeOfParallelism 为 3 来限制同时进行的下载任务数量。

使用 Polly Bulkhead

Polly 是一个强大的 .NET 错误处理和弹性库，它的 Bulkhead 隔板策略可以限制并发任务的数量，并可以选择将超过该数量的任务排队。

示例

using System;
using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Polly;

class Program
{
    static async Task Main(string[] args)
    {
        var bulkhead = Policy.BulkheadAsync(3, Int32.MaxValue); // 最大并发任务数量为 3
        var urls = new List<string> { /* 一系列 URL */ };
        var tasks = new List<Task>();
        foreach (var url in urls)
        {
            var t = bulkhead.ExecuteAsync(async () =>
            {
                var html = await new HttpClient().GetStringAsync(url);
                Console.WriteLine($"retrieved {html.Length} characters from {url}");
            });
            tasks.Add(t);
        }
        await Task.WhenAll(tasks);
    }
}

在这个示例中，我们使用 Polly 的 Bulkhead 隔板策略来限制并发下载任务的数量，并将超过最大并发数量的任务自动排队。

使用 Task.WhenAny

Task.WhenAny 方法可以用于限制并发任务的数量，其基本思路是维护一个任务列表，当任务数量达到阈值时，等待其中一个任务完成，然后继续添加新任务。

示例

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

class Program
{
    static async Task Main(string[] args)
    {
        var urls = new List<string> { /* 一系列 URL */ };
        var maxConcurrentTasks = 3;
        var tasks = new List<Task>();
        foreach (var url in urls)
        {
            tasks.Add(Task.Run(async () =>
            {
                var html = await new HttpClient().GetStringAsync(url);
                Console.WriteLine($"retrieved {html.Length} characters from {url}");
            }));
            if (tasks.Count >= maxConcurrentTasks)
            {
                await Task.WhenAny(tasks);
                tasks = tasks.Where(t => t.Status == TaskStatus.Running).ToList();
            }
        }
        await Task.WhenAll(tasks);
    }
}

在这个示例中，我们通过Task.WhenAny 方法来等待任务列表中的任意一个任务完成，然后移除已完成的任务，从而保持并发任务的数量不超过阈值。

总结

限制并发任务的数量是确保应用程序稳定和高效运行的关键。在 C# 中，我们可以使用SemaphoreSlim、TPL Dataflow、Parallel.ForEach、Polly Bulkhead 和Task.WhenAny 等多种方法来轻松实现这一目标。根据具体的业务需求和应用场景，选择最合适的方法来控制并发任务的数量，可以有效避免资源过度消耗，提高系统的响应速度和可靠性。