异步编程优化：从底层源码看最佳实践

问题背景

在.NET开发中，我们经常会遇到需要封装同步API为异步方法的情况。特别是当底层库没有提供异步版本时，我们不得不使用Task.Run来实现伪异步，这会导致线程池线程的浪费。

本文将从.NET底层源码出发，探讨如何在这种情况下优化异步编程，减少性能开销。

底层源码分析

让我们先看一下.NET 6+中File.WriteAsync的实现：

csharp 复制代码

public static ValueTask WriteAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken = default)
{
    ValidateInput(handle, fileOffset);

    if (cancellationToken.IsCancellationRequested)
    {
        return ValueTask.FromCanceled(cancellationToken);
    }

    return WriteAtOffsetAsync(handle, buffer, fileOffset, cancellationToken);
}

internal static ValueTask WriteAtOffsetAsync(SafeFileHandle handle, ReadOnlyMemory<byte> buffer, long fileOffset, CancellationToken cancellationToken, OSFileStreamStrategy? strategy = null)
    => handle.GetThreadPoolValueTaskSource().QueueWrite(buffer, fileOffset, cancellationToken, strategy);

public sealed partial class SafeFileHandle : SafeHandleZeroOrMinusOneIsInvalid
{
    private ThreadPoolValueTaskSource? _reusableThreadPoolValueTaskSource; // reusable ThreadPoolValueTaskSource that is currently NOT being used

    // Rent the reusable ThreadPoolValueTaskSource, or create a new one to use if we couldn't get one (which
    // should only happen on first use or if the SafeFileHandle is being used concurrently).
    internal ThreadPoolValueTaskSource GetThreadPoolValueTaskSource() =>
        Interlocked.Exchange(ref _reusableThreadPoolValueTaskSource, null) ?? new ThreadPoolValueTaskSource(this);
}

这里的关键是ThreadPoolValueTaskSource，它是.NET 6+为IO操作优化的核心。但对于没有底层异步API的情况，我们需要另寻优化方案。

被迫使用Task.Run的情况

当底层只有同步API时，我们不得不使用Task.Run来实现异步：

arduino 复制代码

// 假设你有一个遗留的同步API（第三方库或旧代码）
public byte[] LegacyEncrypt(byte[] data)  // 纯同步，没有Async版本
{
    // 复杂的CPU计算 + 可能的同步IO
    Thread.Sleep(1000); // 模拟耗时
    return data;
}

// 你的API层暴露为Async
public async Task<byte[]> EncryptAsync(byte[] data)
{
    // ❌ 被迫使用 Task.Run，因为没有底层Async实现
    return await Task.Run(() => LegacyEncrypt(data));
}

这种情况下，Task.Run是唯一的解决方案，但这确实是伪异步（Fake Async），会浪费线程池线程。

优化策略

1. 批量处理（减少线程切换）

scss 复制代码

// ❌ 差：1000次调用 = 1000次线程切换
for (int i = 0; i < 1000; i++)
{
    await Task.Run(() => LegacyEncrypt(data[i])); // 每次都要从线程池拿线程
}

// ✅ 好：1次调用 = 1次线程切换
await Task.Run(() =>
{
    for (int i = 0; i < 1000; i++)
    {
        LegacyEncrypt(data[i]); // 在同一线程内完成
    }
});

2. 专用线程（长时间运行）

ini 复制代码

// 如果LegacyEncrypt是长时间CPU计算，不要占用线程池
public async Task<byte[]> EncryptAsync(byte[] data)
{
    var tcs = new TaskCompletionSource<byte[]>();
    
    // 新建专用线程（Thread池是给短任务的）
    var thread = new Thread(() =>
    {
        try
        {
            var result = LegacyEncrypt(data);
            tcs.SetResult(result);
        }
        catch (Exception ex)
        {
            tcs.SetException(ex);
        }
    });
    
    thread.IsBackground = true;
    thread.Start();
    
    return await tcs.Task;
}

3. 缓存结果（避免重复计算）

csharp 复制代码

// 如果输入重复，避免重复调用
private readonly ConcurrentDictionary<string, byte[]> _cache = new();

public async Task<byte[]> EncryptAsync(byte[] data)
{
    var key = Convert.ToBase64String(data);
    
    if (_cache.TryGetValue(key, out var cached))
        return cached;
    
    var result = await Task.Run(() => LegacyEncrypt(data));
    _cache.TryAdd(key, result);
    return result;
}

专业级封装模式

借鉴.NET底层库的实现，我们可以采用以下模式来优化异步方法的封装：

scss 复制代码

// ✅ 推荐：被迫用Task.Run时的最佳封装
public Task MyLegacyOperationAsync(args, CancellationToken ct)
{
    // 1. 参数验证（同步）
    if (args == null) throw new ArgumentNullException(nameof(args));
    
    // 2. 快速路径（同步完成）
    if (IsCached(args)) return Task.FromResult(cachedValue);
    
    // 3. 取消检查（同步）
    if (ct.IsCancellationRequested) return Task.FromCanceled(ct);
    
    // 4. 慢速路径：被迫的Task.Run
    return Core(args, ct);
    
    static async Task Core(args, CancellationToken ct)  // static避免闭包
    {
        await Task.Run(() => LegacySyncOperation(args), ct);
    }
}

async关键字的使用原则

何时写async关键字

写async的唯一理由：需要在方法内部使用await！

必须写async的情况

csharp 复制代码

// 1. 需要await一个异步操作
public async Task<string> GetDataAsync()
{
    var data = await httpClient.GetStringAsync(url);  // 👈 用了await
    return Process(data);
}

// 2. 需要await多个异步操作
public async Task ProcessAsync()
{
    await Task1();
    await Task2();  // 👈 多个await
    await Task3();
}

// 3. 需要在异步方法中使用using
public async Task ReadFileAsync()
{
    await using var fs = new FileStream(...);  // 👈 await using需要async方法
    await fs.ReadAsync(...);
}

// 4. 需要在catch/finally中await
public async Task ExecuteAsync()
{
    try
    {
        await DoWorkAsync();
    }
    catch (Exception)
    {
        await LogAsync();  // 👈 catch中的await需要async
    }
}

不需要写async的情况

arduino 复制代码

// 1. 直接返回Task，没有await
public Task<string> GetDataAsync()
{
    // 👈 直接返回Task，不需要async
    return httpClient.GetStringAsync(url);
}

// 2. 快速路径模式（你的代码）
public Task DoWorkAsync(CancellationToken ct)
{
    if (ct.IsCancellationRequested)
        return Task.FromCanceled(ct);  // 👈 直接返回
    
    return CoreAsync(ct);  // 👈 委托给另一个异步方法
    
    async Task CoreAsync(CancellationToken ct)
    {
        await Task.Delay(1000);  // 👈 只有这里需要async
    }
}

// 3. 返回已完成的任务
public Task EmptyAsync()
{
    return Task.CompletedTask;  // 👈 没有await
}

// 4. 返回已知结果
public Task<int> GetZeroAsync()
{
    return Task.FromResult(0);  // 👈 没有await
}

性能对比

csharp 复制代码

// ❌ 不好的做法：不必要的async
public async Task<string> BadGetDataAsync()
{
    // 虽然没有await，但因为写了async，还是会生成状态机
    return await httpClient.GetStringAsync(url);  // 👈 多余的await
}

// ✅ 好的做法：去掉async
public Task<string> GoodGetDataAsync()
{
    // 直接返回Task，0状态机开销
    return httpClient.GetStringAsync(url);
}

编译后的区别

arduino 复制代码

// 写法A：写了async
public async Task MethodA()
{
    await Task.Delay(100);
}
// 编译器生成：一个状态机类 + MoveNext方法

// 写法B：没写async
public Task MethodB()
{
    return Task.Delay(100);
}
// 编译器生成：简单的方法调用，无状态机

异常处理差异

arduino 复制代码

// 场景1：async方法中的异常
public async Task AsyncMethod()
{
    throw new Exception("出错");  // 👈 异常被包装到Task中
    await Task.CompletedTask;
}
// 调用时：await时会抛出异常

// 场景2：非async方法中的异常
public Task NonAsyncMethod()
{
    throw new Exception("出错");  // 👈 立即抛出，不包装到Task
    return Task.CompletedTask;
}
// 调用时：直接抛出异常（即使不await）

实战决策树

开始编写方法
需要返回 Task/ValueTask？
需要在方法内使用 await？
- 是 → 必须写 async
  - 可以用 await
  - 可以使用 await using
  - 可以在 catch/finally 中 await
- 否 → 不要写 async
  - 直接返回 Task
  - 可以使用 Task.FromResult
  - 可以实现快速路径优化

最佳实践示例

arduino 复制代码

public class FileService
{
    // ✅ 需要async：因为要await ReadAsync
    public async Task<byte[]> ReadFileAsync(string path)
    {
        using var fs = new FileStream(path, FileMode.Open);
        var buffer = new byte[fs.Length];
        await fs.ReadAsync(buffer);  // 👈 需要await
        return buffer;
    }
    
    // ✅ 不需要async：直接返回Task
    public Task WriteFileAsync(string path, byte[] data)
    {
        return File.WriteAllBytesAsync(path, data);  // 👈 直接返回
    }
    
    // ✅ 快速路径优化：不写async
    public Task ProcessAsync(CancellationToken ct)
    {
        if (ct.IsCancellationRequested)
            return Task.FromCanceled(ct);
        
        return ProcessCoreAsync(ct);
        
        // 只有这里需要async
        async Task ProcessCoreAsync(CancellationToken ct)
        {
            await Task.Delay(1000, ct);
            await ReadFileAsync("test.txt");  // 👈 调用其他async方法
        }
    }
}

扩展思考

ValueTask的使用：对于可能同步完成的操作，使用ValueTask可以减少分配
异步方法的命名：遵循.NET约定，异步方法应以Async结尾
取消令牌的传递：始终在异步方法中传递CancellationToken
异常处理：了解async方法和非async方法的异常处理差异
测试策略：为异步方法编写专门的测试，包括取消和异常场景

总结

通过借鉴.NET底层库的实现模式，我们可以在被迫使用Task.Run的情况下，最小化性能开销，写出更加专业的异步代码。

核心原则是：

只有当你需要在方法内部等待(async/await)时，才写async关键字
利用快速路径优化，减少不必要的状态机开销
合理使用Task.Run，避免线程池饥饿
始终考虑性能和可维护性的平衡

这种优化思路不仅适用于封装同步API的场景，也适用于所有异步编程场景，是每个.NET开发者都应该掌握的技能。