Question

我正在创建一个通用的帮助器类，它将帮助确定对API的请求的优先级，同时限制它们发生的并行化。

考虑以下应用程序的关键方法;

    public IQueuedTaskHandle<TResponse> InvokeRequest<TResponse>(Func<TClient, Task<TResponse>> invocation, QueuedClientPriority priority, CancellationToken ct) where TResponse : IServiceResponse
    {
        var cts = CancellationTokenSource.CreateLinkedTokenSource(ct);
        _logger.Debug("Queueing task.");
        var taskToQueue = Task.Factory.StartNew(async () =>
        {
            _logger.Debug("Starting  request {0}", Task.CurrentId);
            return await invocation(_client);
        }, cts.Token, TaskCreationOptions.None, _schedulers[priority]).Unwrap();
        taskToQueue.ContinueWith(task => _logger.Debug("Finished task {0}", task.Id), cts.Token);
        return new EcosystemQueuedTaskHandle<TResponse>(cts, priority, taskToQueue);
    }

在没有涉及太多细节的情况下，我想调用Task<TResponse>> invocation在队列中出现的任务时返回的任务。我正在使用由唯一枚举索引的QueuedTaskScheduler构建的队列集合;

        _queuedTaskScheduler = new QueuedTaskScheduler(TaskScheduler.Default, 3);
        _schedulers = new Dictionary<QueuedClientPriority, TaskScheduler>();
        //Enumerate the priorities
        foreach (var priority in Enum.GetValues(typeof(QueuedClientPriority)))
        {
            _schedulers.Add((QueuedClientPriority)priority, _queuedTaskScheduler.ActivateNewQueue((int)priority));
        }

然而，由于收效甚微，我无法在有限的并行化环境中执行任务，导致在一个大批量中构建，触发和完成100个API请求。我可以使用Fiddler会话来判断这一点;

enter image description here

我已经阅读了一些有趣的文章和SO帖子（here，here和here）我认为会详细说明如何解决这个问题，但到目前为止我还没有能够弄明白。根据我的理解，lambda的async性质在设计的延续结构中工作，它将生成的任务标记为完整的，基本上是＆＃34; insta-completed＆＃34;它。这意味着虽然队列工作正常，但在自定义调度程序上运行生成的Task<T>会成为问题。

Answer 1

这意味着虽然队列工作正常，但在自定义调度程序上运行生成的任务结果却是问题所在。

正确。考虑它的一种方法[1]是async方法被分成几个任务 - 它在每个await点被分解。然后，在任务调度程序上运行这些“子任务”中的每一个。因此，async方法将完全在任务计划程序上运行（假设您不使用ConfigureAwait(false)），但在每个await处它将保留任务计划程序，然后在await完成后重新输入该任务计划程序。

因此，如果要在更高级别协调异步工作，则需要采用不同的方法。可以为此自己编写代码，但它可能会变得混乱。我建议您先从TPL Dataflow库中尝试ActionBlock<T>，将自定义任务计划程序传递给ExecutionDataflowBlockOptions。

[1]这是一种简化。除非必要，否则状态机将避免创建实际的任务对象（在这种情况下，它们是必需的，因为它们被安排到任务调度程序）。此外，只有等待未完成的await点实际上会导致“方法拆分”。

Answer 2

Stephen Cleary的回答解释了为什么你不能将TaskScheduler用于此目的以及如何使用ActionBlock来限制并行度。但是如果你想为此添加优先级，我认为你必须手动完成。您使用Dictionary队列的方法是合理的，一个简单的实现（不支持取消或完成）可能看起来像这样：

class Scheduler
{
    private static readonly Priority[] Priorities =
        (Priority[])Enum.GetValues(typeof(Priority));

    private readonly IReadOnlyDictionary<Priority, ConcurrentQueue<Func<Task>>> queues;
    private readonly ActionBlock<Func<Task>> executor;
    private readonly SemaphoreSlim semaphore;

    public Scheduler(int degreeOfParallelism)
    {
        queues = Priorities.ToDictionary(
            priority => priority, _ => new ConcurrentQueue<Func<Task>>());

        executor = new ActionBlock<Func<Task>>(
            invocation => invocation(),
            new ExecutionDataflowBlockOptions
            {
                MaxDegreeOfParallelism = degreeOfParallelism,
                BoundedCapacity = degreeOfParallelism
            });

        semaphore = new SemaphoreSlim(0);

        Task.Run(Watch);
    }

    private async Task Watch()
    {
        while (true)
        {
            await semaphore.WaitAsync();

            // find item with highest priority and send it for execution
            foreach (var priority in Priorities.Reverse())
            {
                Func<Task> invocation;
                if (queues[priority].TryDequeue(out invocation))
                {
                    await executor.SendAsync(invocation);
                }
            }
        }
    }

    public void Invoke(Func<Task> invocation, Priority priority)
    {
        queues[priority].Enqueue(invocation);
        semaphore.Release(1);
    }
}

在自定义计划程序

2 个答案: