C# Task：深入理解同步上下文（SynchronizationContext）

在 C# 的异步编程模型中，Task 和 async/await 关键字极大地简化了异步操作的编写。然而，在光鲜亮丽的语法糖背后，隐藏着一个至关重要的概念——同步上下文（SynchronizationContext）。理解同步上下文对于编写健壮、可靠且避免死锁的异步代码至关重要。本文将深入探讨 SynchronizationContext 的作用、工作原理、常见类型以及如何在实际开发中正确使用它。

1. 什么是同步上下文（SynchronizationContext）？

同步上下文（SynchronizationContext）是一个抽象类，它提供了一种机制，用于将委托排队到特定的线程或线程池中执行。更通俗地说，它定义了异步操作完成后，后续的 “continuation”（即 await 之后的代码）应该在哪个“环境”中执行。

这个“环境”可以是：

• UI 线程： 在 Windows Forms 或 WPF 应用程序中，UI 更新必须在 UI 线程上进行。SynchronizationContext 可以确保 continuation 在 UI 线程上执行，从而避免跨线程更新 UI 导致的异常。
• ASP.NET 请求上下文： 在 ASP.NET 应用程序中，每个请求都有其自己的上下文。SynchronizationContext 可以确保 continuation 在原始请求的上下文中执行，从而访问 HttpContext.Current 等请求相关的信息。
• 默认线程池： 如果没有特定的同步上下文，SynchronizationContext 会将 continuation 排队到 .NET 线程池中执行。

SynchronizationContext 的核心方法是 Post 和 Send：

• Post(SendOrPostCallback d, object? state): 异步地将委托 d 排队到同步上下文中执行。state 参数是可选的，可以传递给委托。Post 方法不会阻塞调用线程。
• Send(SendOrPostCallback d, object? state): 同步地将委托 d 排队到同步上下文中执行。Send 方法会阻塞调用线程，直到委托执行完成。

2. 为什么需要同步上下文？

同步上下文的主要作用是：

1. 确保线程安全： 在多线程环境中，直接从不同线程访问共享资源（如 UI 控件）可能会导致竞态条件和数据不一致。SynchronizationContext 提供了一种机制，将对共享资源的访问操作排队到正确的线程上执行，从而确保线程安全。
2. 维护上下文信息： 在某些场景下（如 ASP.NET 请求），我们需要在异步操作的 continuation 中访问与原始上下文相关的信息。SynchronizationContext 可以捕获和恢复这些上下文信息，确保 continuation 能够在正确的上下文中执行。
3. 避免死锁： 在异步编程中，如果不正确地使用 SynchronizationContext，可能会导致死锁。例如，在 UI 线程上同步等待一个异步操作完成，而该异步操作的 continuation 又需要回到 UI 线程执行，就会导致死锁。ConfigureAwait(false) 可以帮助我们避免这种死锁。

3. SynchronizationContext 的工作原理

当使用 async/await 编写异步方法时，编译器会将方法拆分成多个状态机。await 关键字表示一个暂停点，异步操作完成后，会通过 SynchronizationContext 将 continuation（await 之后的代码）排队到适当的线程或上下文中执行。

具体流程如下：

1. 捕获当前上下文： 在 await 表达式之前，会通过 SynchronizationContext.Current 获取当前的同步上下文。如果当前没有同步上下文，则为 null。
2. 执行异步操作： 执行 await 之后的异步操作（例如，Task.Delay、HttpClient.GetAsync 等）。
3. 设置回调： 异步操作完成后，会调用一个回调函数。这个回调函数会检查之前捕获的同步上下文。
4. 排队 continuation：
   • 如果同步上下文不为 null，则通过 SynchronizationContext.Post 方法将 continuation 排队到该上下文中执行。
   • 如果同步上下文为 null，则将 continuation 排队到 .NET 线程池中执行。
5. 恢复上下文： 在 continuation 执行之前，会将 SynchronizationContext.Current 设置为之前捕获的同步上下文（如果存在）。

4. 常见的 SynchronizationContext 类型

.NET Framework 和 .NET 提供了几种内置的 SynchronizationContext 实现：

• WindowsFormsSynchronizationContext： 用于 Windows Forms 应用程序。它将 continuation 排队到 UI 线程上执行，确保 UI 更新的线程安全。
• DispatcherSynchronizationContext： 用于 WPF 和 UWP 应用程序。它将 continuation 排队到 UI 线程的 Dispatcher 队列中执行。
• AspNetSynchronizationContext： 用于 ASP.NET Web Forms 和 MVC 应用程序（非 ASP.NET Core）。它将 continuation 排队到原始请求的上下文中执行，以便访问 HttpContext.Current。ASP.NET Core 不再使用AspNetSynchronizationContext，它有自己的异步处理机制，并且倾向于避免使用HttpContext.Current
• Default (null) SynchronizationContext: 默认行为, 会将 continuation 排队到线程池。

可以使用以下代码获取当前线程的同步上下文：

```csharp
SynchronizationContext? currentContext = SynchronizationContext.Current;

if (currentContext == null)
{
Console.WriteLine("当前没有同步上下文");
}
else
{
Console.WriteLine($"当前同步上下文类型：{currentContext.GetType().Name}");
}
```

5. ConfigureAwait(false) 的作用

在编写异步库或底层代码时，通常不需要将 continuation 强制返回到原始的同步上下文中。在这种情况下，可以使用 ConfigureAwait(false) 来避免不必要的上下文切换，提高性能并减少死锁的可能性。

ConfigureAwait(false) 告诉编译器，在异步操作完成后，不需要捕获和恢复原始的同步上下文。Continuation 将会在线程池中执行，而不是被强制排队到特定的上下文中。

```csharp
public async Task GetDataAsync()
{
// 在某个同步上下文中执行（例如 UI 线程）

using (var client = new HttpClient())
{
    // 使用 ConfigureAwait(false) 避免捕获同步上下文
    string result = await client.GetStringAsync("https://www.example.com").ConfigureAwait(false);

    // 在线程池线程上执行，而不是 UI 线程
    return ProcessData(result);
}

}

private string ProcessData(string data)
{
//对数据进行处理
return data;
}
```

何时使用 ConfigureAwait(false)：

• 编写库代码： 当编写不依赖于特定同步上下文的库代码时，应始终使用 ConfigureAwait(false)。
• 性能优化： 如果 continuation 不需要访问 UI 控件或 ASP.NET 请求上下文，使用 ConfigureAwait(false) 可以减少上下文切换的开销。
• 避免死锁： 在某些情况下，ConfigureAwait(false) 可以帮助避免死锁。

何时不使用 ConfigureAwait(false)：

• UI 编程： 在 UI 应用程序中，如果 continuation 需要更新 UI 控件，则必须在 UI 线程上执行，因此不应使用 ConfigureAwait(false)。
• ASP.NET（非 Core）： 在传统的 ASP.NET 应用程序中，如果 continuation 需要访问 HttpContext.Current，则必须在原始请求的上下文中执行，因此不应使用 ConfigureAwait(false)。
• 需要保持上下文： 如果有任何自定义的逻辑依赖于同步上下文，则不应该使用ConfigureAwait(false).

6. 自定义 SynchronizationContext

在某些特殊情况下，可能需要创建自定义的 SynchronizationContext。例如：

• 实现自定义的调度程序： 可以创建一个 SynchronizationContext，将 continuation 排队到自定义的线程池或任务队列中执行。
• 模拟同步上下文： 在单元测试中，可以创建一个模拟的 SynchronizationContext，以便更好地控制异步操作的执行。
• 限制并发： 建立一个自定义的SynchronizationContext，将并发任务数限制在特定数量。

要创建自定义的 SynchronizationContext，需要继承 SynchronizationContext 类并重写 Post 和 Send 方法。

以下是一个简单的自定义 SynchronizationContext 示例，它将所有 continuation 排队到一个专用的线程中执行：

```csharp
public class SingleThreadSynchronizationContext : SynchronizationContext
{
private readonly BlockingCollection> _queue = new();

public override void Post(SendOrPostCallback d, object? state)
{
    _queue.Add(new KeyValuePair<SendOrPostCallback, object?>(d, state));
}

public override void Send(SendOrPostCallback d, object? state)
{
    // Send 方法通常不在此类简单的 SynchronizationContext 中实现
    throw new NotSupportedException("同步发送不受支持");
}
    public override SynchronizationContext CreateCopy()
{
    return new SingleThreadSynchronizationContext();
}

public void Run()
{
    while (_queue.TryTake(out var workItem, Timeout.Infinite))
    {
        workItem.Key(workItem.Value);
    }
}
//手动停止
 public void Complete()
{
    _queue.CompleteAdding();
}

}

//使用
var context = new SingleThreadSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(context);

// 示例异步操作
async Task DoWorkAsync()
{
Console.WriteLine($"开始执行异步操作，线程 ID：{Thread.CurrentThread.ManagedThreadId}");

await Task.Delay(1000); // 模拟异步操作

Console.WriteLine($"异步操作完成，线程 ID：{Thread.CurrentThread.ManagedThreadId}");

}
//启动
Task.Run(() => context.Run());
//异步调用
DoWorkAsync();
//等待,防止程序提前退出.
Console.ReadKey();
//停止
context.Complete();

```

这个示例中，SingleThreadSynchronizationContext 使用一个 BlockingCollection 来存储排队的委托。Run 方法在一个单独的线程中循环执行队列中的委托。Post 方法只是简单的把委托放到队列中。

7. 异步编程中的常见陷阱和最佳实践

1. 避免在 UI 线程上同步等待异步操作： 这会导致 UI 冻结和死锁。应该使用 async/await 来异步等待操作完成。

   ```csharp
   // 错误：在 UI 线程上同步等待
   private void Button_Click(object sender, EventArgs e)
   {
   string result = GetDataAsync().Result; // 阻塞 UI 线程
   textBox.Text = result;
   }

   // 正确：使用 async/await
   private async void Button_Click(object sender, EventArgs e)
   {
   string result = await GetDataAsync();
   textBox.Text = result;
   }
   ```

2. 在库代码中始终使用 ConfigureAwait(false)： 除非你的库明确需要与特定的同步上下文交互，否则应始终使用 ConfigureAwait(false)。

3. 避免使用 Task.Run 来包装同步代码并在 UI 线程上调用： 这会导致不必要的线程切换，并可能导致 UI 冻结。如果需要在后台执行同步代码，应使用 Task.Run，但不要在 UI 线程上同步等待它。

   ```csharp
   // 错误：在 UI 线程上同步等待 Task.Run
   private void Button_Click(object sender, EventArgs e)
   {
   //错误,这仍旧会阻塞UI线程
   string result = Task.Run(() => LongRunningSyncOperation()).Result;
   textBox.Text = result;
   }

   // 正确：使用 async/await 和 Task.Run
   private async void Button_Click(object sender, EventArgs e)
   {
   string result = await Task.Run(() => LongRunningSyncOperation());
   textBox.Text = result;
   }
   ```

4. 理解 async void 方法的异常处理： async void 方法的异常不会被 try-catch 块捕获，而是会直接抛出到 SynchronizationContext 上。如果没有处理这些异常，可能会导致应用程序崩溃。应尽量避免使用 async void，除非在事件处理程序中。

5. 使用 SynchronizationContext.Current 检查当前上下文： 在某些情况下，可能需要检查当前是否处于特定的同步上下文中。可以使用 SynchronizationContext.Current 来获取当前上下文并进行判断。

8. 深入探索：SynchronizationContext 与 TaskScheduler

除了 SynchronizationContext，还有一个与异步任务调度相关的类：TaskScheduler。虽然它们都涉及到任务的调度和执行，但它们有着不同的职责和用途。

• SynchronizationContext： 主要关注的是 在哪里 执行 continuation。它提供了一种机制，将 continuation 排队到特定的线程或上下文中执行，以确保线程安全和上下文的维护。SynchronizationContext 更加底层，通常与 UI 线程、ASP.NET 请求上下文等概念相关联。
• TaskScheduler： 主要关注的是 如何 调度和执行任务。它定义了任务的调度策略，例如将任务排队到线程池、使用特定的线程优先级、限制并发数等。TaskScheduler 更加高层，通常与 Task 类一起使用。

可以把 TaskScheduler 看作是任务的“调度器”，而 SynchronizationContext 则是任务 continuation 的“执行环境”。

在大多数情况下，我们不需要直接与 TaskScheduler 打交道，因为 .NET 已经提供了默认的线程池调度器（TaskScheduler.Default）。但是，在某些高级场景下，我们可能需要创建自定义的 TaskScheduler 来实现更精细的任务调度控制。

SynchronizationContext 和 TaskScheduler 可以协同工作。例如，我们可以创建一个自定义的 TaskScheduler，它使用自定义的 SynchronizationContext 来执行任务。

9. 继往开来: 异步编程的未来

同步上下文是.NET 异步编程模型的重要组成部分。虽然在许多情况下它可以被忽略，但是深入理解同步上下文，有助于我们写出更稳定、更高效的异步代码。

随着.NET生态的不断发展，我们可以期待在异步编程领域出现更多创新和改进。理解同步上下文的概念和工作原理，将有助于我们更好地适应未来的变化，并充分利用.NET平台提供的强大功能。