使用Task.ContinueWith后计数器结果异常，求原因及异步任务替代方案

嘿，我来帮你梳理下这个问题里的两个核心点——计数器结果异常的原因，还有未启动任务的替代方案～

一、为什么计数器结果不对？ #

你的counter是普通的静态int，但counter++和counter--不是原子操作——底层会拆成「读取当前值→计算新值→写入新值」三个步骤。当10000个任务同时并发执行时，多个线程可能同时读取同一个值，然后各自修改写入，就会出现「丢失更新」的情况，导致最终结果不是0，而且每次都不一样。

修复方法：用线程安全的原子操作 #

把普通的增减改成Interlocked类的原子方法，它能保证这些操作在多线程下是线程安全的：

private static int counter;

public static void Test() {
    List<Task> tasks = new List<Task>();
    for (int i = 0; i < 10000; i++) {
        // 直接用ContinueWith返回的Task，不需要额外的TaskCompletionSource
        var task = DoTaskWork()
            .ContinueWith(t => {
                // 处理t.Result
                Interlocked.Decrement(ref counter); // 原子递减
            });
        tasks.Add(task);
    }
    Task.WaitAll(tasks.ToArray());
    Console.WriteLine(counter); // 现在会稳定输出0
}

private static Task DoTaskWork() {
    Interlocked.Increment(ref counter); // 原子递增
    return Task.Delay(500);
}

另外，这里其实完全不需要TaskCompletionSource——ContinueWith本身就会返回一个代表后续操作完成的Task，直接把这个Task加入列表等待即可，TCS在这里属于多余的封装。

二、未启动任务的替代方案（替代Task构造器） #

你提到需要创建大量未启动的任务，用Task构造器确实有很多限制（不支持await、需要返回类型等），这里推荐两个更合适的方案：

方案1：用Func<Task>封装未启动的异步操作 #

这是最自然的方式——用委托封装异步逻辑，直到你调用委托时，任务才会真正启动，而且完全支持await：

// 存储未启动的异步操作（只是委托，还没执行）
List<Func<Task>> unstartedWork = new List<Func<Task>>();
for (int i = 0; i < 10000; i++) {
    unstartedWork.Add(async () => {
        Interlocked.Increment(ref counter);
        await Task.Delay(500);
        // 处理业务逻辑
        Interlocked.Decrement(ref counter);
    });
}

// 当需要执行时，批量启动所有任务
var runningTasks = unstartedWork.Select(work => work()).ToList();
await Task.WhenAll(runningTasks); // 用await替代WaitAll，更友好

方案2：如果一定要用Task对象（适合同步逻辑） #

如果你的未启动任务是同步代码（不是异步），可以用Task构造器创建，然后按需调用Start()启动，但注意异步逻辑不适合这种方式：

List<Task> unstartedTasks = new List<Task>();
for (int i = 0; i < 10000; i++) {
    // 封装同步逻辑的未启动任务
    var task = new Task(() => {
        Interlocked.Increment(ref counter);
        Thread.Sleep(500); // 同步延迟
        Interlocked.Decrement(ref counter);
    });
    unstartedTasks.Add(task);
}

// 启动所有任务
unstartedTasks.ForEach(t => t.Start());
await Task.WhenAll(unstartedTasks);

额外建议：优先用async/await替代ContinueWith #

ContinueWith是比较旧的异步编程方式，存在上下文捕获、调度器选择等潜在坑点。用async/await改写的代码会更简洁、易读，也更可靠：

public static async Task TestAsync() {
    List<Task> tasks = new List<Task>();
    for (int i = 0; i < 10000; i++) {
        tasks.Add(RunWorkAsync());
    }
    await Task.WhenAll(tasks);
    Console.WriteLine(counter);
}

private static async Task RunWorkAsync() {
    Interlocked.Increment(ref counter);
    await Task.Delay(500);
    // 处理业务逻辑
    Interlocked.Decrement(ref counter);
}

内容的提问来源于stack exchange，提问作者oelsardine