在 .NET Core 中使用 Channel 实现生产者消费者模式

目录

• 一、引言
• 二、假设场景
• 三、解决方案
• 四、示例代码

一、引言

处理大量数据是一个常见的需求，传统的同步处理方式往往效率低下，尤其是在数据量非常大的情况下。本篇将介绍一种高效的多线程异步处理大数据量的方法，通过边处理边消费的方式，极大地提高了处理效率，并且减少了内存开销。这种解决方案只是实现这一需求的一种实践，并不排除还有其他方式可以实现。如果您有任何问题或建议，欢迎在评论区留言讨论。

二、假设场景

假设我们有一个需要处理大量图片文件的应用程序。每个图片文件都需要进行压缩、调整等复杂的计算和数据处理。假设总共需要两个步骤：1、将所有图片文件读取完成；2、拿到步骤1的结果数据，分别对每个图片进行处理。由于图片文件数量庞大，如果按同步方式处理，步骤2必须等待步骤1执行完才能开始工作，不仅速度慢，而且会占用大量内存。

三、解决方案

我们可以使用 .NET 的 异步编程模型 和 Channel 来实现生产者-消费者模式。生产者负责读取图片文件并将其写入到Channel中，消费者从Channel中读取图片文件并进行处理。通过这种方式，我们可以边读取边处理，极大地提高了处理效率。

以下是解决问题的思路和方案：

1. 定义生产者和消费者：
   • 生产者负责读取图片文件，并将其写入到Channel中
   • 消费者从Channel中读取图片文件，并对其进行处理（如压缩、调整大小等）
2. 使用Channel实现生产者-消费者模式：
   • Channel是 .NET 提供的一种用于实现生产者-消费者模式的高效数据结构
   • 生产者将数据写入Channel，消费者从Channel中读取数据
3. 并行处理：
   • 使用Task.Run启动多个生产者和消费者任务，以实现并行处理
   • 通过设置最大并行度来控制同时运行的任务数量
4. 异步编程：
   • 使用async和await关键字实现异步编程，以避免阻塞线程。
   • 异步编程可以提高应用程序的响应速度和吞吐量

涉及技术点介绍：

• Channel：用于在生产者和消费者之间传递数据，支持高效的并发操作
• Task：用于启动并行任务，实现多线程处理
• async/await：用于实现异步编程，避免阻塞线程，提高应用程序的响应速度

四、示例代码

以下是一个简单的示例代码，演示如何使用Channel实现生产者-消费者模式来处理图片文件：

using System.Threading.Channels;

var cts = new CancellationTokenSource();
// 假设有一组图片文件
var imageFiles = Enumerable.Range(0, 1000).Select(x => $"image_{x}.jpg").ToList();

var processor = new ImageProcessor(10, cts.Token);
await processor.ProcessAsync(imageFiles);

Console.ReadKey();

/// <summary>
/// 图片处理器
/// </summary>
/// <param name="maxDegreeOfParallelism">最大并行度</param>
/// <param name="cancellationToken">CancellationToken</param>
public class ImageProcessor(int maxDegreeOfParallelism, CancellationToken cancellationToken)
{
    public async Task ProcessAsync(List<string> imageFiles)
    {
        // 创建一个无界的 Channel
        var channel = Channel.CreateUnbounded<string>();

        // 启动多个生产者任务
        var producerTasks = Enumerable.Range(0, maxDegreeOfParallelism)
            .Select(i => Task.Run(() => Producer(imageFiles, i, channel.Writer), cancellationToken))
            .ToArray();

        // 启动多个消费者任务
        var consumerTasks = Enumerable.Range(0, maxDegreeOfParallelism)
            .Select(_ => Task.Run(() => Consumer(channel.Reader), cancellationToken))
            .ToArray();

        // 等待所有生产者任务完成
        await Task.WhenAll(producerTasks);
        // 完成 Channel 的写入
        channel.Writer.Complete();
        // 等待所有消费者任务完成
        await Task.WhenAll(consumerTasks);
    }

    private async Task Producer(List<string> imageFiles, int producerIndex, ChannelWriter<string> writer)
    {
        try
        {
            // 计算每个生产者需要处理的文件数量
            int filesPerProducer = imageFiles.Count / maxDegreeOfParallelism;
            int start = producerIndex * filesPerProducer;
            int end = producerIndex == maxDegreeOfParallelism - 1
                ? imageFiles.Count
                : start + filesPerProducer;

            for (int i = start; i < end; i++)
            {
                // 模拟读取图片文件
                await Task.Delay(100, cancellationToken);
                // 将图片文件路径写入 Channel
                await writer.WriteAsync(imageFiles[i], cancellationToken);
                Console.WriteLine($"Producer image file: {imageFiles[i]}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Producer error: {ex.Message}");
        }
    }

    private async Task Consumer(ChannelReader<string> reader)
    {
        try
        {
            // 从 Channel 中读取数据并处理
            await foreach (var imageFile in reader.ReadAllAsync(cancellationToken))
            {
                // 模拟处理图片文件（如压缩、调整大小等）
                await Task.Delay(100, cancellationToken);
                Console.WriteLine($"Processed image file: {imageFile}");
            }
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Consumer error: {ex.Message}");
        }
    }
}