并行编程模式是C#中用于处理多任务并发执行的重要技术，旨在充分利用多核处理器和异步机制来提高性能和响应性

于 2025-08-28 12:36:16 发布
阅读量633 收藏 11
点赞数 11
CC 4.0 BY-SA版权
分类专栏： 李工篇 C#实战教程 文章标签： 大数据 云计算 hadoop
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhxup606/article/details/148458317

并行编程模式是C#中用于处理多任务并发执行的重要技术，旨在充分利用多核处理器和异步机制来提高性能和响应性。结合《CLR via C#》第19章（线程基础）和第20章（异步编程）的知识，以及现代.NET（.NET 5+）的特性，我将深入讲解C#中的并行编程模式，重点包括并行编程的核心概念、常见模式、深入代码示例、经典案例、优化技巧、常见问题与易错点，并针对特定场景（如WPF、ASP.NET Core）提供定制化示例。内容深入且结构清晰，适合中高级开发者。

一、并行编程核心概念

1.1 概述

并行编程通过同时执行多个任务（task）或线程（thread）来加速计算密集型或I/O密集型操作。C#中的并行编程主要基于线程池、Task Parallel Library (TPL) 和 async/await，由CLR的线程管理和异步状态机支持。

关键点

  • 线程（Thread）：

    • CLR的基本执行单元，适合长时间运行的任务。

    • 创建和管理开销大，推荐使用线程池。

  • 线程池（ThreadPool）：

    • 管理一组可重用线程，减少创建/销毁开销。

    • 适合短生命周期任务，如Task.Run。

  • Task Parallel Library (TPL)：

    • 基于System.Threading.Tasks，提供高级抽象（如Task、Parallel）。

    • 支持并行循环（Parallel.For）、并行任务（Task.WhenAll）等。

  • 异步编程（async/await）：

    • 适合I/O密集型任务，结合Task实现非阻塞操作。

    • 可与并行编程结合，处理混合负载。

  • 同步原语：

    • lock、Monitor、SemaphoreSlim等用于线程安全。

    • Concurrent集合（如ConcurrentDictionary）简化并发数据访问。

  • 性能考虑：

    • 并行编程需平衡任务分割、线程开销和资源竞争。

    • 过度并行可能导致上下文切换开销或资源耗尽。

与CLR的关系

  • CLR管理线程调度、线程池和任务状态机，确保并行操作的类型安全和异常处理。

  • 元数据支持反射（如动态任务创建），异步状态机支持async/await。

  • CLR的垃圾回收（GC）和内存模型影响并行程序的性能。

二、常见并行编程模式

以下是C#中常见的并行编程模式，每种模式适合不同场景，搭配深入示例和分析。

2.1 数据并行（Data Parallelism）

  • 描述：将大数据集分割为小块，分配到多个线程并行处理。

  • 工具：Parallel.For、Parallel.ForEach、PLINQ（Parallel LINQ）。

  • 适用场景：计算密集型任务（如图像处理、数据分析）。

  • 注意事项：确保线程安全，避免共享状态竞争。

示例：并行处理图像像素

csharp

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        int[] pixels = new int[1000000]; // 模拟图像像素
        Parallel.For(0, pixels.Length, i =>
        {
            pixels[i] = ProcessPixel(i); // 并行处理每个像素
        });
        Console.WriteLine("Image processed.");
    }

    static int ProcessPixel(int value)
    {
        // 模拟复杂计算
        return value * 2;
    }
}

  • 说明：

    • Parallel.For自动分割循环，分配到线程池线程。

    • 每个线程独立处理像素子集，无需锁。

    • 适合CPU密集型任务。

2.2 任务并行（Task Parallelism）

  • 描述：多个独立任务并行执行，互不依赖。

  • 工具：Task.Run、Task.WhenAll。

  • 适用场景：异构任务（如同时下载多个文件、调用多个API）。

  • 注意事项：管理任务依赖和异常。

示例：并行下载多个网页

csharp

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

class Program
{
    static async Task Main()
    {
        string[] urls = { "https://example.com", "https://google.com", "https://x.com" };
        var tasks = new List<Task<string>>();

        foreach (var url in urls)
        {
            tasks.Add(Task.Run(() => DownloadContentAsync(url)));
        }

        try
        {
            string[] results = await Task.WhenAll(tasks);
            for (int i = 0; i < results.Length; i++)
            {
                Console.WriteLine($"Content from {urls[i]}: {results[i].Substring(0, 50)}...");
            }
        }
        catch (HttpRequestException ex)
        {
            Console.WriteLine($"Error: {ex.Message}");
        }
    }

    static async Task<string> DownloadContentAsync(string url)
    {
        using var client = new HttpClient();
        return await client.GetStringAsync(url).ConfigureAwait(false);
    }
}

  • 说明：

    • Task.Run将I/O操作分发到线程池。

    • Task.WhenAll等待所有任务完成，处理聚合异常。

    • ConfigureAwait(false)优化性能，适合非UI场景。

2.3 生产者-消费者模式（Producer-Consumer）

  • 描述：生产者生成数据，消费者并行处理，解耦生产和消费。

  • 工具：BlockingCollection<T>、ConcurrentQueue<T>、异步流（IAsyncEnumerable<T>）。

  • 适用场景：流式数据处理（如日志处理、消息队列）。

  • 注意事项：控制缓冲区大小，避免生产者过快导致内存溢出。

示例：并行处理日志流

csharp

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

class Program
{
    static async Task Main()
    {
        var queue = new BlockingCollection<string>(boundedCapacity: 100);
        var producer = Task.Run(() => ProduceLogs(queue));
        var consumers = new[]
        {
            Task.Run(() => ConsumeLogs(queue, 1)),
            Task.Run(() => ConsumeLogs(queue, 2))
        };

        await Task.WhenAll(producer, Task.WhenAll(consumers));
        Console.WriteLine("Processing complete.");
    }

    static void ProduceLogs(BlockingCollection<string> queue)
    {
        for (int i = 0; i < 10; i++)
        {
            queue.Add($"Log {i}");
            Task.Delay(100).Wait(); // 模拟生产延迟
        }
        queue.CompleteAdding();
    }

    static void ConsumeLogs(BlockingCollection<string> queue, int consumerId)
    {
        foreach (var log in queue.GetConsumingEnumerable())
        {
            Console.WriteLine($"Consumer {consumerId}: {log}");
            Task.Delay(200).Wait(); // 模拟处理延迟
        }
    }
}

  • 说明：

    • BlockingCollection<T>管理生产者-消费者队列，限制缓冲区大小。

    • 多个消费者并行处理日志，GetConsumingEnumerable阻塞直到有数据。

    • CompleteAdding通知消费者队列结束。

2.4 异步流并行处理

  • 描述：结合IAsyncEnumerable<T>和并行任务处理流式数据。

  • 工具：IAsyncEnumerable<T>、Task.WhenAll。

  • 适用场景：实时数据流（如WebSocket、传感器数据）。

  • 注意事项：控制并发度，避免资源耗尽。

示例：并行处理异步流

csharp

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

class Program
{
    static async Task Main()
    {
        var semaphore = new SemaphoreSlim(2); // 限制并发
        var tasks = new List<Task>();

        await foreach (var item in GenerateItemsAsync())
        {
            await semaphore.WaitAsync();
            tasks.Add(Task.Run(async () =>
            {
                try
                {
                    await ProcessItemAsync(item);
                }
                finally
                {
                    semaphore.Release();
                }
            }));
        }

        await Task.WhenAll(tasks);
        Console.WriteLine("All items processed.");
    }

    static async IAsyncEnumerable<int> GenerateItemsAsync()
    {
        for (int i = 0; i < 10; i++)
        {
            await Task.Delay(100);
            yield return i;
        }
    }

    static async Task ProcessItemAsync(int item)
    {
        await Task.Delay(200); // 模拟处理
        Console.WriteLine($"Processed item {item}");
    }
}

  • 说明：

    • IAsyncEnumerable<T>生成流式数据。

    • SemaphoreSlim限制并发处理为2。

    • 每个item异步处理，保持非阻塞。

三、经典案例

  1. 图像处理（数据并行）：

    • 场景：并行处理大图像的像素（如灰度转换）。

    • 实现：使用Parallel.For分割像素数组，分配到多核。

    • 效果：利用多核CPU，显著缩短处理时间。

  2. 批量API调用（任务并行）：

    • 场景：ASP.NET Core API并行调用多个外部服务。

    • 实现：使用Task.WhenAll和IHttpClientFactory。

    • 效果：减少总响应时间，提高吞吐量。

  3. 实时日志处理（生产者-消费者）：

    • 场景：从文件或网络流读取日志，多个消费者并行分析。

    • 实现：使用BlockingCollection<T>和多个Task。

    • 效果：解耦生产与消费，高效处理高吞吐量日志。

  4. 流式数据分析（异步流）：

    • 场景：实时处理传感器数据流。

    • 实现：结合IAsyncEnumerable<T>和SemaphoreSlim并行处理。

    • 效果：低内存占用，支持实时更新。

四、特定场景代码（WPF和ASP.NET Core）

4.1 WPF并行编程

WPF需要并行编程来处理计算密集型任务，同时保持UI响应性。

示例：并行处理数据并更新UI

csharp

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

namespace WpfApp
{
    public partial class MainWindow : Window
    {
        public MainWindow()
        {
            InitializeComponent();
        }

        private async void ProcessButton_Click(object sender, RoutedEventArgs e)
        {
            try
            {
                var progress = new Progress<int>(value => ProgressBar.Value = value);
                var results = await ProcessDataAsync(progress);
                DataGrid.ItemsSource = results;
            }
            catch (Exception ex)
            {
                MessageBox.Show($"Error: {ex.Message}");
            }
        }

        private async Task<List<string>> ProcessDataAsync(IProgress<int> progress)
        {
            var data = new int[1000];
            var results = new List<string>();
            int count = 0;

            await Task.Run(() =>
            {
                Parallel.For(0, data.Length, i =>
                {
                    data[i] = i * 2; // 模拟计算
                    if (Interlocked.Increment(ref count) % 100 == 0)
                    {
                        progress.Report(count / 10);
                    }
                });
            });

            foreach (var item in data)
            {
                results.Add($"Item {item}");
            }
            return results;
        }
    }
}

  • 说明：

    • Parallel.For在后台线程处理计算密集型任务。

    • IProgress<int>报告进度，更新UI（ProgressBar）。

    • Task.Run确保计算不阻塞UI线程。

    • try-catch捕获异常，显示错误信息。

优化：异步流更新UI

csharp

private async void StartButton_Click(object sender, RoutedEventArgs e)
{
    try
    {
        await foreach (var item in GenerateItemsAsync())
        {
            DataGrid.Items.Add(item); // 实时更新UI
        }
    }
    catch (Exception ex)
    {
        MessageBox.Show($"Error: {ex.Message}");
    }
}

static async IAsyncEnumerable<string> GenerateItemsAsync()
{
    for (int i = 0; i < 10; i++)
    {
        await Task.Delay(500);
        yield return $"Item {i}";
    }
}

  • 说明：

    • IAsyncEnumerable<T>实时生成数据，适合动态UI更新。

    • UI线程自动恢复，保持响应性。

最佳实践

  • 避免UI线程阻塞：使用Task.Run或Parallel将计算卸载到线程池。

  • 进度反馈：使用IProgress<T>更新UI。

  • 线程安全：UI更新需在UI线程执行（WPF自动处理await恢复）。

4.2 ASP.NET Core并行编程

ASP.NET Core利用并行编程处理高并发请求，优化服务器性能。

示例：并行API请求

csharp

using Microsoft.AspNetCore.Mvc;
using System.Net.Http;
using System.Threading.Tasks;
using Microsoft.Extensions.DependencyInjection;

[ApiController]
[Route("api/[controller]")]
public class DataController : ControllerBase
{
    private readonly IHttpClientFactory _clientFactory;

    public DataController(IHttpClientFactory clientFactory)
    {
        _clientFactory = clientFactory;
    }

    [HttpGet("fetch")]
    public async Task<IActionResult> FetchData()
    {
        var urls = new[] { "https://example.com", "https://google.com", "https://x.com" };
        var tasks = new System.Collections.Generic.List<Task<string>>();

        foreach (var url in urls)
        {
            var client = _clientFactory.CreateClient();
            tasks.Add(client.GetStringAsync(url));
        }

        try
        {
            string[] results = await Task.WhenAll(tasks);
            return Ok(results);
        }
        catch (HttpRequestException ex)
        {
            return StatusCode(500, ex.Message);
        }
    }
}

  • 说明：

    • IHttpClientFactory管理HttpClient生命周期。

    • Task.WhenAll并行执行请求，减少响应时间。

    • 异常处理返回HTTP 500状态码。

优化：限流和重试

csharp

using Microsoft.AspNetCore.Mvc;
using Polly;
using System.Net.Http;
using System.Threading;
using System.Threading.Tasks;

[ApiController]
[Route("api/[controller]")]
public class DataController : ControllerBase
{
    private readonly IHttpClientFactory _clientFactory;

    public DataController(IHttpClientFactory clientFactory)
    {
        _clientFactory = clientFactory;
    }

    [HttpGet("fetch-limited")]
    public async Task<IActionResult> FetchDataLimited()
    {
        var urls = new[] { "https://example.com", "https://google.com", "https://x.com" };
        var semaphore = new SemaphoreSlim(2); // 限制并发
        var tasks = new System.Collections.Generic.List<Task<string>>();
        var policy = Policy
            .Handle<HttpRequestException>()
            .RetryAsync(3);

        foreach (var url in urls)
        {
            await semaphore.WaitAsync();
            tasks.Add(policy.ExecuteAsync(async () =>
            {
                try
                {
                    var client = _clientFactory.CreateClient();
                    return await client.GetStringAsync(url);
                }
                finally
                {
                    semaphore.Release();
                }
            }));
        }

        try
        {
            string[] results = await Task.WhenAll(tasks);
            return Ok(results);
        }
        catch (Exception ex)
        {
            return StatusCode(500, ex.Message);
        }
    }
}

  • 说明：

    • SemaphoreSlim限制并发为2，防止服务器过载。

    • Polly实现重试机制，提高可靠性。

    • IHttpClientFactory优化HTTP客户端管理。

最佳实践

  • 全异步链路：从控制器到服务层使用async/await。

  • 限流：使用SemaphoreSlim或中间件控制并发。

  • 重试和容错：结合Polly处理网络失败。

  • 监控：使用ILogger或Application Insights记录性能。

五、优化技巧

  1. 控制并发度：

    • 使用SemaphoreSlim或ParallelOptions.MaxDegreeOfParallelism限制线程数。

    • 示例：

      csharp

      var options = new ParallelOptions { MaxDegreeOfParallelism = 4 };
Parallel.ForEach(data, options, item => Process(item));

  2. 使用ValueTask<T>：

    • 高频操作使用ValueTask<T>减少Task分配。

    • 示例：

      csharp

      async ValueTask<int> ComputeAsync(int input) => input < 0 ? -1 : await Task.FromResult(input * 2);

  3. 线程安全集合：

    • 使用ConcurrentBag<T>、ConcurrentDictionary<T>等避免锁。

    • 示例：

      csharp

      var results = new ConcurrentBag<string>();
Parallel.ForEach(data, item => results.Add(Process(item)));

  4. 分区优化：

    • 使用Partioner自定义数据分割，优化负载均衡。

    • 示例：

      csharp

      var partitioner = Partitioner.Create(0, data.Length, 1000);
Parallel.ForEach(partitioner, range =>
{
    for (int i = range.Item1; i < range.Item2; i++)
    {
        Process(data[i]);
    }
});

  5. 混合负载优化：

    • I/O密集型任务用async/await，计算密集型任务用Parallel或Task.Run。

    • 示例：

      csharp

      async Task ProcessMixedAsync()
{
    await Task.Run(() => Parallel.For(0, 100, i => Compute(i)));
    await DownloadAsync();
}

六、常见问题与易错点

  1. 死锁：

    • 问题：UI线程中调用Task.Result或嵌套锁导致死锁。

    • 解决：

      csharp

      // 错误
var result = DownloadAsync().Result;

// 正确
var result = await DownloadAsync().ConfigureAwait(false);

  2. 竞争条件：

    • 问题：共享资源未同步，导致数据损坏。

    • 解决：使用lock或Concurrent集合。

      csharp

      var results = new ConcurrentBag<int>();
Parallel.For(0, 100, i => results.Add(i));

  3. 过度并行：

    • 问题：过多线程导致上下文切换开销。

    • 解决：限制并发度，使用SemaphoreSlim或MaxDegreeOfParallelism。

  4. 异常丢失：

    • 问题：Task.WhenAll中一个任务失败，可能忽略其他异常。

    • 解决：

      csharp

      try
{
    await Task.WhenAll(tasks);
}
catch (AggregateException ex)
{
    foreach (var inner in ex.InnerExceptions)
    {
        Console.WriteLine(inner.Message);
    }
}

  5. 资源耗尽：

    • 问题：无限制并发导致内存或CPU耗尽。

    • 解决：使用限流机制和对象池。

七、与《CLR via C#》的联系

  • 第19章（线程基础）：

    • 讲解线程、线程池和同步原语，介绍Parallel类的实现。

    • 强调线程安全和性能优化。

  • 第20章（异步编程）：

    • 讲解Task和异步状态机，适用于I/O密集型并行任务。

    • 讨论Task.WhenAll和ConfigureAwait。

  • 现代.NET补充：

    • IAsyncEnumerable<T>（.NET Core 3.0+）扩展流式并行处理。

    • ValueTask<T>和IHttpClientFactory优化高并发。

    • 建议参考X上的讨论（如搜索“.NET parallel programming”）或官方文档。

八、总结

  • 并行编程模式：

    • 数据并行（Parallel.For、PLINQ）适合计算密集型任务。

    • 任务并行（Task.WhenAll）适合异构任务。

    • 生产者-消费者（BlockingCollection<T>）适合流式处理。

    • 异步流（IAsyncEnumerable<T>）适合实时数据。

  • WPF：结合Task.Run和IProgress<T>处理计算任务，保持UI响应。

  • ASP.NET Core：使用Task.WhenAll、SemaphoreSlim和Polly优化高并发API。

  • 优化关键：控制并发度、使用线程安全集合、结合ValueTask<T>和限流机制。

如果需要更具体的代码（如PLINQ优化、WPF复杂数据处理、ASP.NET Core信号量中间件）或性能分析，请告诉我，我可以进一步扩展！

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

一萍一世界

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值