异步与并发深入

// 常规异步方法
public async Task<Order> GetOrderAsync(int id)
{
    await Task.Delay(10); // 模拟 IO
    return new Order(id);
}

// ValueTask：适合「经常同步返回」的热路径
public ValueTask<Order> GetOrderCachedAsync(int id)
{
    if (cache.TryGetValue(id, out var order))
        return new ValueTask<Order>(order);   // 同步完成，零分配
    return new ValueTask<Order>(LoadFromDbAsync(id));
}

private async Task<Order> LoadFromDbAsync(int id)
{
    await Task.Delay(50);
    return new Order(id);
}

// 表面写法
async Task<Order> GetOrderAsync(int id)
{
    var user = await GetUserAsync(id);        // 挂起点 1
    var address = await GetAddressAsync(id);  // 挂起点 2
    return new Order(user, address);
}

// 概念等价的状态机（编译器生成，示意）
// MoveNext 里保存 resume point，两个 await 之间可让出线程

// 创建取消源并设置超时
using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5));

async Task<string> FetchAsync(CancellationToken ct)
{
    using var http = new HttpClient();
    // 把令牌传给每个支持取消的调用
    return await http.GetStringAsync(url, ct);
}

// 显式取消
cts.Cancel();

// 超时保护：不传令牌的调用也能被 WaitAsync 兜底
var result = await longOperation.WaitAsync(TimeSpan.FromSeconds(3), ct);

// 自己实现支持取消的循环
async Task ProcessAsync(IAsyncEnumerable<int> items, CancellationToken ct)
{
    await foreach (var item in items.WithCancellation(ct))
    {
        ct.ThrowIfCancellationRequested(); // 安全检查点
        await HandleAsync(item, ct);
    }
}

// ASP.NET Core 中：每请求上下文
public async Task<IActionResult> Get(int id)
{
    var data = await _repo.GetAsync(id);   // 默认捕获请求上下文
    return Ok(data);
}

// 库代码：不依赖上下文，明确放弃捕获
public async Task<string> ReadFileAsync(string path)
{
    await using var fs = File.OpenRead(path);
    using var reader = new StreamReader(fs);
    return await reader.ReadToEndAsync().ConfigureAwait(false);
}

// Parallel.For 处理 CPU 密集任务
var results = new double[1_000_000];
Parallel.For(0, results.Length, i =>
{
    results[i] = Math.Sqrt(i) * Math.Sin(i);
});

// ConcurrentDictionary 的安全更新
var counts = new ConcurrentDictionary<string, int>();
Parallel.ForEach(words, word =>
{
    // 组合操作仍要加锁：AddOrUpdate 保证原子
    counts.AddOrUpdate(word, 1, (_, n) => n + 1);
});

// 并发队列：生产消费者
var queue = new ConcurrentQueue<string>();
queue.Enqueue("task-1");
if (queue.TryDequeue(out var item))
{
    Console.WriteLine(item);
}

// 有界 Channel：容量 100，生产过快会等待
var channel = Channel.CreateBounded<int>(
    new BoundedChannelOptions(100)
    {
        FullMode = BoundedChannelFullMode.Wait
    });

// 生产者
async Task ProduceAsync(ChannelWriter<int> writer, CancellationToken ct)
{
    for (int i = 0; i < 1000; i++)
    {
        await writer.WriteAsync(i, ct);
    }
    writer.Complete(); // 通知消费者结束
}

// 消费者
async Task ConsumeAsync(ChannelReader<int> reader, CancellationToken ct)
{
    await foreach (var item in reader.ReadAllAsync(ct))
    {
        Console.WriteLine(item);
    }
}

// 组合运行
var producer = ProduceAsync(channel.Writer, ct);
var consumer = ConsumeAsync(channel.Reader, ct);
await Task.WhenAll(producer, consumer);

// 陷阱 1：同步包异步 → 线程池饥饿
public string Bad()
{
    return GetAsync().GetAwaiter().GetResult(); // 阻塞线程池线程
}

// 陷阱 2：Task.Run 包同步 IO（IO 不需要额外线程）
public async Task<string> BadIo()
{
    return await Task.Run(() => File.ReadAllText("a.txt")); // 浪费线程
}

// 陷阱 3：async void 异常逃逸
async void BadEvent() => throw new InvalidOperationException();

// 正例：全程异步穿透，只在入口层阻塞
public async Task<string> Good()
{
    return await GetAsync(); // 一路 async/await
}