ContinueWith 委托在 Task 完成之前运行

Question

背景信息：我正在尝试创建一个能够同时处理 5 个并发操作的单例类。每个操作都由SomeAsyncMethod 表示。

---

此方法存在于单例类中。

consumers 是ConcurrentDictionary<int,Task>

我的问题：由于某种原因，ContinueWith 委托在SomeAsyncMethod 完成之前运行。我知道发生这种情况的原因是因为我有另一种方法可以监视instance.Consumers.Count - 在SomeAsyncMethod 完成之前计数是0。

为什么会这样？

    public bool TryAddDequeueRequest()
    {
        if (instance.Consumers.Count < 5)
        {
            Task bogusTask;
            Task newTask = new Task(SomeAsyncMethod);

            //RUNS AFTER THE REQUEST IS COMPLETED
            newTask.ContinueWith(t =>
            {
                instance.Consumers.TryRemove(t.Id, out bogusTask);
            });

            //WE ADD THE TASK TO QUEUE
            instance.Consumers.TryAdd(newTask.Id, newTask);

            //SET IT AND FORGET IT
            newTask.Start();



            return true;
        }
        else
            return false;
    }

Answer 1

SomeAsyncMethod，如果它的名字有任何指示，它是一个异步方法，大概是返回一个Task。您正在创建一个新任务以在另一个线程中开始此异步操作。 Task 将在您完成启动异步操作时返回，而不是在它启动的异步操作完成时返回。

虽然您可以解开任务，但更简单的选择是首先不将其打包。在异步方法返回的Task 上调用延续：

SomeAsyncMethod().ContinueWith(t =>
{
    instance.Consumers.TryRemove(t.Id, out bogusTask);
});
instance.Consumers.TryAdd(newTask.Id, newTask);

当然，如果您希望能够以固定的并行化程度执行一些异步操作，还有更简单的方法。您可以使用SemaphoreSlim 相当简单地创建任何固定并行度的工作队列：

public class FixedParallelismQueue
{
    private SemaphoreSlim semaphore;
    public FixedParallelismQueue(int maxDegreesOfParallelism)
    {
        semaphore = new SemaphoreSlim(maxDegreesOfParallelism);
    }

    public async Task<T> Enqueue<T>(Func<Task<T>> taskGenerator)
    {
        await semaphore.WaitAsync();
        try
        {
            return await taskGenerator();
        }
        finally
        {
            semaphore.Release();
        }
    }
    public async Task Enqueue(Func<Task> taskGenerator)
    {
        await semaphore.WaitAsync();
        try
        {
            await taskGenerator();
        }
        finally
        {
            semaphore.Release();
        }
    }
}

Answer 2

由于SomeAsyncMethod 是异步的，它在完成其自己的 任务之前返回。

如果您可以控制 SomeAsyncMethod 的代码，则将其重构为同步（没有 await/async），或者如果已经有非异步版本，则使用它。

如果你无法控制方法的代码，你可以在周围的任务中等待它完成后再继续：

Task newTask = new Task(()=>{ SomeAsyncMethod().Wait(); });