📘 第27章：计算密集型异步操作

随着计算密集型操作对性能的要求越来越高，多线程编程和异步操作已成为现代应用程序的标准。特别是在计算密集型任务中，如何高效利用 CPU 资源并进行合理的线程调度和任务管理，成为了开发者们面临的重要挑战。《CLR via C#》的第27章聚焦于计算密集型异步操作，提供了一些关键概念与实用技术，帮助我们在 C# 中高效执行并发操作。

🎯 1. 线程池简介

在 CLR 中，线程池是处理并发任务的重要工具。它管理线程的生命周期，允许应用程序复用线程，避免了频繁创建和销毁线程的高开销。

• 线程池的优势：

  • 性能优化：减少线程创建和销毁的开销。
  • 简化管理：CLR 自动管理线程池中的线程，开发者无需直接控制线程的创建和销毁。

ThreadPool.QueueUserWorkItem(ComputeTask);

这种方式允许将任务排队到线程池中，线程池会自动选择一个线程来执行该任务。

线程池工作原理：

• CLR 管理线程池中的多个工作线程。
• 线程池中的线程复用而不被频繁创建。
• 任务提交后，线程池会根据工作负载动态地调节线程数。

⚙️ 2. 执行上下文（Execution Contexts）

执行上下文代表线程执行过程中的环境状态（如当前线程的执行栈、同步上下文、文化信息等）。CLR 会在执行任务时自动管理上下文信息，保证线程在任务切换时的状态不丢失。

• 同步上下文：特别重要于 UI 线程和后台任务的交互，确保 UI 更新能在主线程上安全进行。
• 调用上下文：与 Thread.CurrentThread 相关，可以保存一些如文化信息、SecurityContext 等信息。

ExecutionContext.Run(ExecutionContext.Capture(), new ContextCallback((state) => {
    // 执行代码
}), null);

🕐 3. 计算密集型任务的异步处理

计算密集型任务（例如图像处理、数据分析、加密算法等）通常会占用大量 CPU 时间，导致应用程序的响应性差。为了有效执行计算密集型操作，异步编程与线程池的结合至关重要。

• 线程池是处理计算密集型操作时的理想选择，因为它能够在多个 CPU 核心之间分配任务，提高并行处理能力。
• 异步任务的管理：使用 Task.Run 可以轻松将计算密集型任务分配到线程池中。

Task.Run(() => {
    PerformHeavyComputation();
});

这种方法不仅可以避免主线程被阻塞，还能确保应用程序的响应性。

🔄 4. 协作取消与超时

在执行异步任务时，往往需要有取消和超时的机制，尤其是在执行长时间运行的计算密集型任务时，确保任务可以在合适的时机中止。

1. 取消操作：

CancellationToken 是 C# 提供的协作取消机制，它允许开发者手动取消正在执行的任务。

CancellationTokenSource cts = new CancellationTokenSource();
CancellationToken token = cts.Token;

Task.Run(() => {
    for (int i = 0; i < 1000; i++) {
        if (token.IsCancellationRequested) {
            break;
        }
        // 执行计算
    }
}, token);

2. 设置超时：

可以通过 Task.WhenAny 或 CancellationToken 实现任务的超时控制。

var task = Task.Run(() => PerformHeavyComputation());
if (await Task.WhenAny(task, Task.Delay(5000)) == task) {
    // 任务完成
} else {
    // 超时
    cts.Cancel();
}

🧩 5. 任务（Task）与任务工厂（Task Factory）

Task 是异步操作的核心。Task 提供了易于使用的异步控制流，可以启动、等待并控制并发任务。与线程不同，Task 管理的是异步操作，而非直接的线程。

任务工厂（TaskFactory）：

任务工厂是一个便捷的方式，用于批量创建和启动多个任务，并能统一管理这些任务的生命周期。

TaskFactory factory = new TaskFactory();
Task[] tasks = new Task[3];
for (int i = 0; i < 3; i++) {
    tasks[i] = factory.StartNew(() => {
        PerformHeavyComputation();
    });
}
Task.WaitAll(tasks);

这种方式简化了任务的管理和调度，特别是在高并发环境下非常有用。

🔄 6. 任务调度器（Task Schedulers）

C# 中的任务调度器允许开发者指定任务的执行环境。例如，可以创建自定义的任务调度器，将任务限制在特定的线程池中，或者指定任务在特定的时间段执行。

• 默认任务调度器：CLR 提供了默认的调度器，用于将任务分配到线程池。
• 自定义任务调度器：在特定场景下（如高优先级任务），你可以创建自定义的调度器来精确控制任务的执行顺序。

TaskScheduler customScheduler = new CustomTaskScheduler();
Task.Factory.StartNew(() => {
    PerformHeavyComputation();
}, CancellationToken.None, TaskCreationOptions.None, customScheduler);

🔄 7. Parallel 类的静态方法

Parallel 类 提供了用于并行执行操作的静态方法：

• Parallel.For：并行执行循环。
• Parallel.ForEach：并行执行集合中的每个元素。
• Parallel.Invoke：并行执行多个方法。

Parallel.For(0, 1000, i => {
    Console.WriteLine($"Processing {i}");
});

这些方法让开发者无需手动创建线程即可并行执行多个任务，极大地简化了并发编程。

🕰 8. 定时执行计算密集型任务

对于某些需要周期性执行的计算任务，可以使用 Timer 类来控制任务的执行间隔。

Timer timer = new Timer(state => {
    PerformHeavyComputation();
}, null, 0, 1000); // 每秒执行一次

Timer 适合处理周期性任务，但要注意避免任务执行时间过长导致定时器频繁触发。

💡 总结

• 线程池和任务：是计算密集型异步操作的基础。线程池帮助复用线程，提高 CPU 使用效率，而 Task 类则简化了异步操作的管理。
• 并行编程：Parallel.For 和 Parallel.ForEach 提供了非常简洁的并行编程模型，帮助开发者高效利用多核处理器。
• 任务取消与超时：通过 CancellationToken 和 Task.WhenAny 实现任务取消与超时控制，确保任务按时完成。
• 任务调度与工厂：通过 TaskScheduler 和 TaskFactory，开发者可以更加灵活地控制任务的执行策略，确保并发任务的合理调度。

🎯 1. Unity 中如何避免在主线程上执行计算密集型操作？

解析：
Unity 的主线程负责渲染、输入处理和大多数 Unity API 的调用，因此应避免阻塞操作。可以通过 Task.Run() 或 线程池 将计算密集型逻辑移出主线程执行，然后通过 Main Thread Dispatcher 或回调机制回到主线程更新 UI。

Task.Run(() => {
    var result = HeavyComputation();
    UnityMainThreadDispatcher.Enqueue(() => UpdateUI(result));
});

🎯面试题

🎯 2. Unity 如何处理线程安全问题？在多线程环境下如何操作 Unity API？

解析：
Unity 的大部分 API 只能在主线程访问。若在其他线程中调用如 Transform, GameObject, UI 等相关 API，可能会引发崩溃或未定义行为。解决方式是：

• 在后台线程中处理计算、逻辑。
• 通过 Dispatcher、Coroutines 或 SynchronizationContext 切回主线程操作 Unity API。

SynchronizationContext context = SynchronizationContext.Current;
Task.Run(() => {
    var result = Calculate();
    context.Post(_ => ApplyToUnityAPI(result), null);
});

🎯 3. 如何使用 ThreadPool 或 Task 在 Unity 中实现并发计算任务？

解析：
ThreadPool 和 Task 都是适用于计算密集型任务的工具。在 Unity 中使用它们处理不涉及 Unity API 的任务（如路径查找、数据加密）非常合适。

Task.Run(() => {
    var path = CalculatePath();
    resultReady = true;
});

使用时注意：

• 不要在子线程访问 UnityEngine 的对象。
• 用 Task.WhenAll 聚合多个任务，处理批量并发需求。

🎯 4. Unity 中的协程（Coroutine）和 Task 有何异同？如何结合使用？

解析：

基于 MonoBehaviour/Unity Engine .NET ThreadPool、异步模型 执行位置 Unity 主线程 线程池子线程或主线程 并发能力 伪并发，非真正多线程 真正并发/多线程处理 等待机制 yield returnawait 典型应用 游戏逻辑流程、动画过渡 I/O或计算密集型任务

特性	协程 Coroutine	Task / async-await

结合使用示例：

IEnumerator LoadData() {
    Task<string> task = Task.Run(() => LoadFromDisk());
    yield return new WaitUntil(() => task.IsCompleted);
    Debug.Log(task.Result);
}

🎯 5. 在 Unity 中实现任务取消时，如何优雅地控制异步任务的超时和中止？

解析：
通过 CancellationTokenSource 实现取消控制，结合 Task.WhenAny 实现超时逻辑，既保证任务响应性，又避免长时间阻塞。

CancellationTokenSource cts = new CancellationTokenSource();
var token = cts.Token;

var task = Task.Run(() => {
    while (!token.IsCancellationRequested) {
        // 模拟长任务
    }
}, token);

if (await Task.WhenAny(task, Task.Delay(3000)) != task) {
    cts.Cancel(); // 超时取消任务
}

注意：

• 子任务中必须轮询 IsCancellationRequested。
• 在 Unity 中结合 Coroutine 回主线程展示取消结果。