处理包装任务的有限并发级别任务调度程序（具有任务优先级）
我很难找到一个任务调度程序，我可以在其上安排优先级任务，但也可以处理“包装”任务。 它类似于Task.Run尝试解决的问题，但您无法为Task.Run指定任务计划Task.Run 。 我一直在使用Parallel Extensions Extras Samples中的QueuedTaskScheduler来解决任务优先级要求（也是本文的建议）。
这是我的例子：
class Program { private static QueuedTaskScheduler queueScheduler = new QueuedTaskScheduler(targetScheduler: TaskScheduler.Default, maxConcurrencyLevel: 1); private static TaskScheduler ts_priority1; private static TaskScheduler ts_priority2; static void Main(string[] args) { ts_priority1 = queueScheduler.ActivateNewQueue(1); ts_priority2 = queueScheduler.ActivateNewQueue(2); QueueValue(1, ts_priority2); QueueValue(2, ts_priority2); QueueValue(3, ts_priority2); QueueValue(4, ts_priority1); QueueValue(5, ts_priority1); QueueValue(6, ts_priority1); Console.ReadLine(); } private static Task QueueTask(Func f, TaskScheduler ts) { return Task.Factory.StartNew(f, CancellationToken.None, TaskCreationOptions.HideScheduler | TaskCreationOptions.DenyChildAttach, ts); } private static Task QueueValue(int i, TaskScheduler ts) { return QueueTask(async () => { Console.WriteLine("Start {0}", i); await Task.Delay(1000); Console.WriteLine("End {0}", i); }, ts); } }
上面示例的典型输出是：
Start 4 Start 5 Start 6 Start 1 Start 2 Start 3 End 4 End 3 End 5 End 2 End 1 End 6
我想要的是：
Start 4 End 4 Start 5 End 5 Start 6 End 6 Start 1 End 1 Start 2 End 2 Start 3 End 3
编辑：
我想我正在寻找一个类似于QueuedTaskScheduler的任务调度程序，它将解决这个问题。 但欢迎任何其他建议。
不幸的是，使用TaskScheduler无法解决这个问题，因为它们始终在Task级别Task ，而async方法几乎总是包含多个Task 。
您应该将SemaphoreSlim与优先级调度程序结合使用。 或者，您可以使用AsyncLock （它也包含在我的AsyncEx库中 ）。
class Program { private static QueuedTaskScheduler queueScheduler = new QueuedTaskScheduler(targetScheduler: TaskScheduler.Default, maxConcurrencyLevel: 1); private static TaskScheduler ts_priority1; private static TaskScheduler ts_priority2; private static SemaphoreSlim semaphore = new SemaphoreSlim(1); static void Main(string[] args) { ts_priority1 = queueScheduler.ActivateNewQueue(1); ts_priority2 = queueScheduler.ActivateNewQueue(2); QueueValue(1, ts_priority2); QueueValue(2, ts_priority2); QueueValue(3, ts_priority2); QueueValue(4, ts_priority1); QueueValue(5, ts_priority1); QueueValue(6, ts_priority1); Console.ReadLine(); } private static Task QueueTask(Func f, TaskScheduler ts) { return Task.Factory.StartNew(f, CancellationToken.None, TaskCreationOptions.HideScheduler | TaskCreationOptions.DenyChildAttach, ts).Unwrap(); } private static Task QueueValue(int i, TaskScheduler ts) { return QueueTask(async () => { await semaphore.WaitAsync(); try { Console.WriteLine("Start {0}", i); await Task.Delay(1000); Console.WriteLine("End {0}", i); } finally { semaphore.Release(); } }, ts); } }
我能找到的最佳解决方案是制作我自己的QueuedTaskScheduler版本（原始版本在Parallel Extensions Extras Samples源代码中找到）。
我将一个bool awaitWrappedTasks参数添加到bool awaitWrappedTasks的构造函数中。
public QueuedTaskScheduler( TaskScheduler targetScheduler, int maxConcurrencyLevel, bool awaitWrappedTasks = false) { ... _awaitWrappedTasks = awaitWrappedTasks; ... } public QueuedTaskScheduler( int threadCount, string threadName = "", bool useForegroundThreads = false, ThreadPriority threadPriority = ThreadPriority.Normal, ApartmentState threadApartmentState = ApartmentState.MTA, int threadMaxStackSize = 0, Action threadInit = null, Action threadFinally = null, bool awaitWrappedTasks = false) { ... _awaitWrappedTasks = awaitWrappedTasks; // code starting threads (removed here in example) ... }
然后我将ProcessPrioritizedAndBatchedTasks()方法修改为async
private async void ProcessPrioritizedAndBatchedTasks()
然后，我在执行计划任务的部分之后修改了代码：
private async void ProcessPrioritizedAndBatchedTasks() { bool continueProcessing = true; while (!_disposeCancellation.IsCancellationRequested && continueProcessing) { try { // Note that we're processing tasks on this thread _taskProcessingThread.Value = true; // Until there are no more tasks to process while (!_disposeCancellation.IsCancellationRequested) { // Try to get the next task. If there aren't any more, we're done. Task targetTask; lock (_nonthreadsafeTaskQueue) { if (_nonthreadsafeTaskQueue.Count == 0) break; targetTask = _nonthreadsafeTaskQueue.Dequeue(); } // If the task is null, it's a placeholder for a task in the round-robin queues. // Find the next one that should be processed. QueuedTaskSchedulerQueue queueForTargetTask = null; if (targetTask == null) { lock (_queueGroups) FindNextTask_NeedsLock(out targetTask, out queueForTargetTask); } // Now if we finally have a task, run it. If the task // was associated with one of the round-robin schedulers, we need to use it // as a thunk to execute its task. if (targetTask != null) { if (queueForTargetTask != null) queueForTargetTask.ExecuteTask(targetTask); else TryExecuteTask(targetTask); // ***** MODIFIED CODE START **** if (_awaitWrappedTasks) { var targetTaskType = targetTask.GetType(); if (targetTaskType.IsConstructedGenericType && typeof(Task).IsAssignableFrom(targetTaskType.GetGenericArguments()[0])) { dynamic targetTaskDynamic = targetTask; // Here we await the completion of the proxy task. // We do not await the proxy task directly, because that would result in that await will throw the exception of the wrapped task (if one existed) // In the continuation we then simply return the value of the exception object so that the exception (stored in the proxy task) does not go totally unobserved (that could cause the process to crash) await TaskExtensions.Unwrap(targetTaskDynamic).ContinueWith((Func)(t => t.Exception), TaskContinuationOptions.ExecuteSynchronously); } } // ***** MODIFIED CODE END **** } } } finally { // Now that we think we're done, verify that there really is // no more work to do. If there's not, highlight // that we're now less parallel than we were a moment ago. lock (_nonthreadsafeTaskQueue) { if (_nonthreadsafeTaskQueue.Count == 0) { _delegatesQueuedOrRunning--; continueProcessing = false; _taskProcessingThread.Value = false; } } } } }
方法ThreadBasedDispatchLoop的更改有点不同，因为我们不能使用async关键字，否则我们将破坏在专用线程中执行计划任务的function。 所以这是ThreadBasedDispatchLoop的修改版本
private void ThreadBasedDispatchLoop(Action threadInit, Action threadFinally) { _taskProcessingThread.Value = true; if (threadInit != null) threadInit(); try { // If the scheduler is disposed, the cancellation token will be set and // we'll receive an OperationCanceledException. That OCE should not crash the process. try { // If a thread abort occurs, we'll try to reset it and continue running. while (true) { try { // For each task queued to the scheduler, try to execute it. foreach (var task in _blockingTaskQueue.GetConsumingEnumerable(_disposeCancellation.Token)) { Task targetTask = task; // If the task is not null, that means it was queued to this scheduler directly. // Run it. if (targetTask != null) { TryExecuteTask(targetTask); } // If the task is null, that means it's just a placeholder for a task // queued to one of the subschedulers. Find the next task based on // priority and fairness and run it. else { // Find the next task based on our ordering rules... QueuedTaskSchedulerQueue queueForTargetTask; lock (_queueGroups) FindNextTask_NeedsLock(out targetTask, out queueForTargetTask); // ... and if we found one, run it if (targetTask != null) queueForTargetTask.ExecuteTask(targetTask); } if (_awaitWrappedTasks) { var targetTaskType = targetTask.GetType(); if (targetTaskType.IsConstructedGenericType && typeof(Task).IsAssignableFrom(targetTaskType.GetGenericArguments()[0])) { dynamic targetTaskDynamic = targetTask; // Here we wait for the completion of the proxy task. // We do not wait for the proxy task directly, because that would result in that Wait() will throw the exception of the wrapped task (if one existed) // In the continuation we then simply return the value of the exception object so that the exception (stored in the proxy task) does not go totally unobserved (that could cause the process to crash) TaskExtensions.Unwrap(targetTaskDynamic).ContinueWith((Func)(t => t.Exception), TaskContinuationOptions.ExecuteSynchronously).Wait(); } } } } catch (ThreadAbortException) { // If we received a thread abort, and that thread abort was due to shutting down // or unloading, let it pass through. Otherwise, reset the abort so we can // continue processing work items. if (!Environment.HasShutdownStarted && !AppDomain.CurrentDomain.IsFinalizingForUnload()) { Thread.ResetAbort(); } } } } catch (OperationCanceledException) { } } finally { // Run a cleanup routine if there was one if (threadFinally != null) threadFinally(); _taskProcessingThread.Value = false; } }
我测试了这个，它给出了所需的输出。 此技术也可用于任何其他调度程序。 例如， OrderedTaskScheduler和OrderedTaskScheduler
我认为实现这一目标是不可能的。 核心问题似乎是TaskScheduler只能用于运行代码。 但是有些任务不运行代码，例如IO任务或计时器任务。 我不认为TaskScheduler基础设施可以用来安排那些。
从TaskScheduler的角度来看，它看起来像这样：
1. Select a registered task for execution 2. Execute its code on the CPU 3. Repeat
步骤（2）是同步的，这意味着要执行的Task必须作为步骤（2）的一部分开始和结束。 这意味着此Task无法执行异步IO，因为这将是非阻塞的。 从这个意义上讲， TaskScheduler仅支持阻止代码。
我认为通过实现自己的AsyncSemaphore版本可以提供最佳服务，该版本以优先级顺序释放服务员并进行限制。 您的异步方法可以以非阻塞方式等待该信号量。 所有CPU工作都可以在默认线程池上运行，因此无需在自定义TaskScheduler启动自定义线程。 IO任务可以继续使用非阻塞IO。