在C#中，Task.Run 和 Task.WaitAll 是用于异步编程和任务并行处理的重要方法

原创于 2025-06-06 13:10:35 发布 · 893 阅读

16 ·

CC 4.0 BY-SA版权

文章标签：

#c# #开发语言

C#实战教程专栏收录该内容

366 篇文章

订阅专栏

在C#中，Task.Run 和 Task.WaitAll 是用于异步编程和任务并行处理的重要方法。以下是对代码 task1 = Task.Run, task2 = Task.Run, Task.WaitAll(task1, task2) 的解释：

Task.Run:
- Task.Run 是 .NET 中 Task 类的静态方法，用于在线程池中异步执行一个委托（通常是一个方法或 Lambda 表达式）。
- 语法：Task.Run(() => { /* 任务代码 */ })。
- 作用：将指定的工作（任务）调度到线程池中运行，返回一个 Task 对象，表示该异步操作。
- 在你的例子中，task1 = Task.Run 和 task2 = Task.Run 表示创建了两个异步任务（具体任务内容未提供，假设是某个方法或 Lambda 表达式）。
Task.WaitAll(task1, task2):
- Task.WaitAll 是一个静态方法，用于阻塞当前线程，直到所有指定的任务（task1 和 task2）都完成。
- 语法：Task.WaitAll(Task[] tasks)。
- 作用：确保 task1 和 task2 都执行完毕后，程序才会继续执行后续代码。
- 注意：Task.WaitAll 是同步等待，会阻塞调用线程，直到所有任务完成。如果在 UI 线程或上位机主线程中调用，可能会导致界面卡死。
代码整体含义:
- 这段代码表示：
  - 使用 Task.Run 创建并启动两个异步任务 task1 和 task2。
  - 使用 Task.WaitAll(task1, task2) 等待这两个任务全部完成。
- 适合需要并行执行多个任务并确保所有任务完成后继续执行的场景。

上位机使用该方法的注意事项

在上位机（通常指工业控制、数据采集、监控系统等软件）中使用 Task.Run 和 Task.WaitAll 时，需要特别注意以下事项，以避免性能问题或错误：

避免在主线程中调用 Task.WaitAll:
- 上位机通常有图形用户界面（GUI），GUI 线程（主线程）负责处理用户交互和界面更新。
- 如果在主线程中调用 Task.WaitAll，会阻塞主线程，导致界面无响应（卡死）。
- 解决方案：
  - 使用 async/await 代替 Task.WaitAll，以异步方式等待任务完成。例如：
    
    csharp
```
async Task RunTasksAsync()
{
    var task1 = Task.Run(() => { /* 任务1 */ });
    var task2 = Task.Run(() => { /* 任务2 */ });
    await Task.WhenAll(task1, task2); // 异步等待
}
```
  - 将 Task.Run 和 Task.WhenAll 放在 async 方法中，并在主线程中调用时使用 await。
避免长时间运行的任务阻塞线程池:
- Task.Run 使用线程池线程执行任务。如果任务是长时间运行的（例如 CPU 密集型任务或长时间 I/O 操作），可能会耗尽线程池资源。
- 解决方案：
  - 对于长时间运行的任务，考虑使用 Task.Factory.StartNew 并指定 TaskCreationOptions.LongRunning：
    
    csharp
```
var task1 = Task.Factory.StartNew(() => { /* 任务1 */ }, TaskCreationOptions.LongRunning);
```
  - 优化任务逻辑，尽量将任务拆分为小块，减少对线程池的压力。

异常处理:

Task.WaitAll 会抛出 AggregateException，其中包含所有任务中发生的异常。
如果任务抛出未处理的异常，Task.WaitAll 会立即返回并抛出异常，导致程序可能崩溃。

解决方案：

使用 try-catch 捕获异常：

csharp

try
{
    Task.WaitAll(task1, task2);
}
catch (AggregateException ex)
{
    foreach (var innerEx in ex.InnerExceptions)
    {
        Console.WriteLine($"任务异常: {innerEx.Message}");
    }
}

或者使用 await Task.WhenAll 并在任务内部处理异常：

csharp

async Task RunTasksAsync()
{
    try
    {
        var task1 = Task.Run(() => { /* 任务1，可能抛异常 */ });
        var task2 = Task.Run(() => { /* 任务2，可能抛异常 */ });
        await Task.WhenAll(task1, task2);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"任务异常: {ex.Message}");
    }
}

避免在高实时性场景中使用 Task.WaitAll:
- 上位机通常对实时性要求较高，Task.WaitAll 的阻塞特性可能导致延迟。
- 解决方案：
  - 使用 Task.WhenAll 结合 async/await 实现非阻塞等待。
  - 如果需要实时性，考虑使用事件驱动模型或消息队列来协调任务。
任务优先级和资源管理:
- 线程池线程的优先级可能影响任务执行顺序，需确保任务不会因为优先级问题导致延迟。
- 解决方案：
  - 必要时手动设置线程优先级（谨慎使用，避免破坏线程池调度）。
  - 监控线程池状态，避免资源耗尽。

共享资源如何避免错误

在多任务并行执行（如 task1 和 task2）时，如果任务访问共享资源（如全局变量、文件、数据库、硬件设备等），可能引发以下问题：

数据竞争（Race Condition）：多个任务同时读写共享资源，导致数据不一致。
死锁（Deadlock）：任务因争夺资源而相互等待，无法继续执行。
资源访问冲突：例如，同时写入文件或硬件端口导致错误。

以下是避免共享资源错误的建议：

使用锁机制（Lock）：

使用 lock 关键字确保同一时间只有一个任务访问共享资源：

csharp

private readonly object _lock = new object();
private int sharedCounter = 0;

var task1 = Task.Run(() =>
{
    lock (_lock)
    {
        sharedCounter++;
        Console.WriteLine($"Task1: {sharedCounter}");
    }
});

var task2 = Task.Run(() =>
{
    lock (_lock)
    {
        sharedCounter++;
        Console.WriteLine($"Task2: {sharedCounter}");
    }
});

Task.WaitAll(task1, task2);

注意：lock 必须在所有任务中使用同一个锁对象（_lock）。

使用线程安全集合：

如果共享资源是集合（如 List、Dictionary），使用线程安全的集合类：

ConcurrentDictionary, ConcurrentQueue, ConcurrentBag 等。

示例：

csharp

private readonly ConcurrentDictionary<int, string> sharedData = new ConcurrentDictionary<int, string>();

var task1 = Task.Run(() =>
{
    sharedData.TryAdd(1, "Task1");
});

var task2 = Task.Run(() =>
{
    sharedData.TryAdd(2, "Task2");
});

Task.WaitAll(task1, task2);

避免死锁：

死锁通常发生在多个任务以不同顺序获取多个锁。

解决方案：

始终以固定顺序获取锁：

csharp

private readonly object _lock1 = new object();
private readonly object _lock2 = new object();

var task1 = Task.Run(() =>
{
    lock (_lock1)
    {
        lock (_lock2)
        {
            // 访问资源
        }
    }
});

var task2 = Task.Run(() =>
{
    lock (_lock1) // 同一顺序
    {
        lock (_lock2)
        {
            // 访问资源
        }
    }
});

使用 Monitor.TryEnter 设置超时，避免无限等待：

csharp

if (Monitor.TryEnter(_lock, TimeSpan.FromSeconds(5)))
{
    try
    {
        // 访问资源
    }
    finally
    {
        Monitor.Exit(_lock);
    }
}
else
{
    Console.WriteLine("获取锁超时");
}

使用原子操作：

对于简单共享资源（如计数器），使用 Interlocked 类进行原子操作，避免锁开销：

csharp

private int sharedCounter = 0;

var task1 = Task.Run(() =>
{
    Interlocked.Increment(ref sharedCounter);
});

var task2 = Task.Run(() =>
{
    Interlocked.Increment(ref sharedCounter);
});

Task.WaitAll(task1, task2);

分离任务数据：
- 尽量让每个任务操作独立的数据，减少共享资源的使用。
- 示例：将共享资源拆分为每个任务的本地副本，任务完成后合并结果。
硬件资源访问：
- 上位机常涉及硬件（如串口、PLC、传感器）。多任务访问同一硬件可能导致冲突。
- 解决方案：
  - 使用单一任务管理硬件通信，其他任务通过消息队列或事件与该任务交互。
  - 示例：创建一个硬件管理类，内部使用锁或队列处理请求：
    
    csharp
```
public class HardwareManager
{
    private readonly object _lock = new object();

    public void SendCommand(string command)
    {
        lock (_lock)
        {
            // 硬件操作，例如串口写入
        }
    }
}
```
日志记录与调试：
- 在多任务环境中，记录任务执行日志有助于排查共享资源问题。
- 使用线程安全的日志工具（如 Serilog 或自定义线程安全日志类）。

总结

代码解释：Task.Run 创建异步任务，Task.WaitAll 同步等待任务完成。
上位机注意事项：
- 避免在主线程使用 Task.WaitAll，优先使用 async/await 和 Task.WhenAll。
- 处理异常，避免线程池耗尽，优化任务设计。
共享资源保护：
- 使用锁、线程安全集合、原子操作、固定锁顺序等方法避免数据竞争和死锁。
- 硬件资源访问需集中管理，减少冲突。