C#中并行编程（Parallel Programming）的原理解析及使用演示

C# 中的并行编程（Parallel Programming）是一种利用多核处理器或多台计算机来同时执行多个任务的编程技术。通过并行编程，可以提高程序的执行效率，特别是在处理大量数据或计算密集型任务时。

并行编程的原理

并行编程的核心思想是将一个大任务分解成多个小任务，然后同时执行这些小任务。在 C# 中，并行编程主要通过以下几种方式实现：

1. 任务并行库（Task Parallel Library, TPL）：

   • TPL 是 .NET Framework 4.0 引入的一个库，提供了高级的并行编程模型。

   • 主要类包括 Parallel 类和 Task 类。

2. 并行 LINQ（PLINQ）：

   • PLINQ 是 LINQ 的并行版本，允许对 LINQ 查询进行并行化处理。

3. 异步编程模型（Async/Await）：

   • 异步编程模型通过 async 和 await 关键字实现异步操作，虽然不是严格的并行编程，但可以提高程序的响应性。

使用演示

1. 使用 Parallel.For 和 Parallel.ForEach

Parallel.For 和 Parallel.ForEach 是 TPL 提供的两个常用方法，用于并行执行循环。

csharp

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        // 使用 Parallel.For 并行执行循环
        Parallel.For(0, numbers.Length, i =>
        {
            Console.WriteLine($"Parallel.For: Processing number {numbers[i]} on thread {Task.CurrentId}");
        });

        // 使用 Parallel.ForEach 并行执行循环
        Parallel.ForEach(numbers, number =>
        {
            Console.WriteLine($"Parallel.ForEach: Processing number {number} on thread {Task.CurrentId}");
        });
    }
}

2. 使用 Task 类

Task 类表示一个异步操作，可以用于并行执行多个任务。

csharp

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        // 创建多个任务
        Task task1 = Task.Run(() => DoWork("Task 1"));
        Task task2 = Task.Run(() => DoWork("Task 2"));
        Task task3 = Task.Run(() => DoWork("Task 3"));

        // 等待所有任务完成
        Task.WaitAll(task1, task2, task3);

        Console.WriteLine("All tasks completed.");
    }

    static void DoWork(string taskName)
    {
        Console.WriteLine($"{taskName} is running on thread {Task.CurrentId}");
        Task.Delay(1000).Wait(); // 模拟工作
        Console.WriteLine($"{taskName} completed.");
    }
}

3. 使用 PLINQ

PLINQ 允许对 LINQ 查询进行并行化处理。

csharp

using System;
using System.Linq;

class Program
{
    static void Main()
    {
        int[] numbers = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

        // 使用 PLINQ 并行处理数据
        var result = numbers.AsParallel()
                            .Where(n => n % 2 == 0)
                            .Select(n => n * n);

        foreach (var number in result)
        {
            Console.WriteLine(number);
        }
    }
}

4. 使用 async 和 await

async 和 await 关键字用于实现异步编程，虽然不是严格的并行编程，但可以提高程序的响应性。

csharp

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Console.WriteLine("Starting async operations...");

        Task<int> task1 = DoAsyncWork("Task 1", 1000);
        Task<int> task2 = DoAsyncWork("Task 2", 2000);
        Task<int> task3 = DoAsyncWork("Task 3", 3000);

        // 等待所有任务完成
        int[] results = await Task.WhenAll(task1, task2, task3);

        Console.WriteLine("All async operations completed.");
        Console.WriteLine($"Results: {string.Join(", ", results)}");
    }

    static async Task<int> DoAsyncWork(string taskName, int delay)
    {
        Console.WriteLine($"{taskName} is starting...");
        await Task.Delay(delay); // 模拟异步工作
        Console.WriteLine($"{taskName} completed.");
        return delay;
    }
}

总结

C# 中的并行编程通过 TPL、PLINQ 和异步编程模型提供了强大的工具来利用多核处理器的能力。通过合理使用这些工具，可以显著提高程序的执行效率和响应性。在实际开发中，应根据具体需求选择合适的并行编程技术。