C#TaskScheduler 任务调度器的原理

什么是TaskScheduler？

SynchronizationContext是对“调度程序（scheduler）”的通用抽象。个别框架会有自己的抽象调度程序，比如System.Threading.Tasks。当Tasks通过委托的形式进行排队和执行时，会用到System.Threading.Tasks.TaskScheduler。和SynchronizationContext提供了一个virtual Post方法用于将委托排队调用一样（稍后，我们会通过典型的委托调用机制来调用委托），TaskScheduler也提供了一个abstract QueueTask方法（稍后，我们会通过ExecuteTask方法来调用该Task）。

通过TaskScheduler.Default我们可以获取到Task默认的调度程序ThreadPoolTaskScheduler——线程池（译注：这下知道为什么Task默认使用的是线程池线程了吧）。并且可以通过继承TaskScheduler来重写相关方法来实现在任意时间任意地点进行Task调用。例如，核心库中有个类，名为System.Threading.Tasks.ConcurrentExclusiveSchedulerPair，其实例公开了两个TaskScheduler属性，一个叫ExclusiveScheduler，另一个叫ConcurrentScheduler。调度给ConcurrentScheduler的任务可以并发，但是要在构造ConcurrentExclusiveSchedulerPair时就要指定最大并发数（类似于前面演示的MaxConcurrencySynchronizationContext）；相反，在ExclusiveScheduler执行任务时，那么将只允许运行一个排他任务，这个行为很像读写锁。

和SynchronizationContext一样，TaskScheduler也有一个Current属性，会返回当前调度程序。不过，和SynchronizationContext不同的是，它没有设置当前调度程序的方法，而是在启动Task时就要提供，因为当前调度程序是与当前运行的Task相关联的。所以，下方的示例程序会输出“True”，这是因为和StartNew一起使用的lambda表达式是在ConcurrentExclusiveSchedulerPair的ExclusiveScheduler上执行的（我们手动指定cesp.ExclusiveScheduler），并且TaskScheduler.Current也

using System;
using System.Threading.Tasks;

class Program
{
    static void Main()
    {
        var cesp = new ConcurrentExclusiveSchedulerPair();
        Task.Factory.StartNew(() =>
        {
            Console.WriteLine(TaskScheduler.Current == cesp.ExclusiveScheduler);
        }, default, TaskCreationOptions.None, cesp.ExclusiveScheduler)
        .Wait();
    }
}

TaskScheduler  任务调度器的原理

public abstract class TaskScheduler
{
    // 任务入口，待调度执行的 Task 会通过该方法传入，调度器会将任务安排task到指定的队列（线程池任务队列（全局任务队列、本地队列）、独立线程、ui线程） 只能被.NET Framework调用，不能配派生类调用
   //
    protected internal abstract void QueueTask(Task task);

    // 这个是在执行 Task 回调的时候才会被执行到的方法，放到后面再讲
    protected abstract bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued);

  protected abstract bool TryExecuteTask(Task task, bool taskWasPreviouslyQueued);

// 获取所有调度到该 TaskScheduler 的 Task

 protected abstract IEnumerable<Task>? GetScheduledTasks();
 }

.net中的任务调度器有哪些

线程池任务调度器：ThreadPoolTaskScheduler、
核心库任务调度器：ConcurrentExclusiveSchedulerPair
UI任务调度器：SynchronizationContextTaskScheduler，并发度为1

平时我们在用多线程开发的时候少不了Task，确实task给我们带来了巨大的编程效率，在Task底层有一个TaskScheduler，它决定了task该如何被调度，而

在.net framework中有两种系统定义Scheduler，第一个是Task默认的ThreadPoolTaskScheduler，还是一种就是SynchronizationContextTaskScheduler（wpf），默认的调度器无法控制任务优先级，那么需要自定义调度器实现优先级控制。

以及这两种类型之外的如何自定义，这篇刚好和大家分享一下。

一: ThreadPoolTaskScheduler

这种scheduler机制是task的默认机制，而且从名字上也可以看到它是一种委托到ThreadPool的机制，刚好也从侧面说明task是基于ThreadPool基础上的

封装，源代码

ThreadPoolTaskScheduler的原理：将指定的长任务开辟一个独立的线程去执行，未指定的长时间运行的任务就用线程池的线程执行

 internal sealed class ThreadPoolTaskScheduler : TaskScheduler
    {
//其他代码
   protected internal override void QueueTask(Task task)
        {
            TaskCreationOptions options = task.Options;
            if (Thread.IsThreadStartSupported && (options & TaskCreationOptions.LongRunning) != 0)
            {
                // Run LongRunning tasks on their own dedicated thread.
                new Thread(s_longRunningThreadWork)
                {
                    IsBackground = true,
                    Name = ".NET Long Running Task"
                }.UnsafeStart(task);
            }
            else
            {
                // Normal handling for non-LongRunning tasks.
                ThreadPool.UnsafeQueueUserWorkItemInternal(task, (options & TaskCreationOptions.PreferFairness) == 0);
            }
        }
//其他代码

 }

二：SynchronizationContextTaskScheduler

使用条件：只有当前程的同步上下文不为null时，该方法才能正常使用。例如在UI线程（wpf、 winform、 asp.net）中，UI线程的同步上下文不为Null。控制台默认的当前线程同步上下文为null，如果给当前线程设置默认的同步上下文SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());就可以正常使用该方法。如果控制台程序的线程未设置同步上下将引发【当前的 SynchronizationContext 不能用作 TaskScheduler】异常。

默认的同步上下文将方法委托给线程池执行。

使用方式：通过TaskScheduler.FromCurrentSynchronizationContext() 调用SynchronizationContextTaskScheduler。

原理：初始化时候捕获当前的线程的同步上下文。 将同步上下文封装入任务调度器形成新的任务调度器SynchronizationContextTaskScheduler。重写该任务调度器中的QueueTask方法，利用同步上下文的post方法将任务送到不同的处理程序，如果是

winform的UI线程同步上下文 的post方法（已重写post方法），就将任务送到UI线程。如果是控制台线程（默认为null 设置默认同步上下文后可以正常使用。默认同步上下文采用线程池线程）就将任务送入线程池处理。

在winform中的同步上下文：WindowsFormsSynchronizationContext
在wpf中的同步上下文：DispatcherSynchronizationContext
在控制台\线程池\new thread 同步上下文：都默认为Null。可以给他们设置默认的同步上下文SynchronizationContext。SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());

SynchronizationContext 综述 | Microsoft Docs

以下是SynchronizationContextTaskScheduler部分源代码

 internal sealed class SynchronizationContextTaskScheduler : TaskScheduler
    {

//初始化时候 ，捕获当前线程的同步上下文
 internal SynchronizationContextTaskScheduler()
        {
            m_synchronizationContext = SynchronizationContext.Current ??
                // make sure we have a synccontext to work with
                throw new InvalidOperationException(SR.TaskScheduler_FromCurrentSynchronizationContext_NoCurrent);
        }

//其他代码
private readonly SynchronizationContext m_synchronizationContext;
protected internal override void QueueTask(Task task)
        {
            m_synchronizationContext.Post(s_postCallback, (object)task);
        }
//其他代码
///改变post的调度方法、 调用者线程执行各方面的任务操作

  private static readonly SendOrPostCallback s_postCallback = static s =>
        {
            Debug.Assert(s is Task);
            ((Task)s).ExecuteEntry(); //调用者线程执行各方面的任务操作
        };
 }

网站源代码

以下是SynchronizationContext部分源代码

  public partial class SynchronizationContext
    {
　　　　//其他代码
　　　　public virtual void Post(SendOrPostCallback d, object? state) => ThreadPool.QueueUserWorkItem(static s => s.d(s.state), (d, state), preferLocal: false);
　　 //其他代码
　　}

网站源代码

有了这个基础我们再来看一下代码怎么写，可以看到，下面这段代码是不阻塞UIThread的，完美~~~

private void button1_Click(object sender, EventArgs e)
         {
             Task task = Task.Factory.StartNew(() =>
             {
                 //复杂操作，等待10s
                 Thread.Sleep(10000);

             }).ContinueWith((t) =>
             {
                 button1.Text = "hello world";
             }, TaskScheduler.FromCurrentSynchronizationContext());
         }

三：自定义TaskScheduler　

　　我们知道在现有的.net framework中只有这么两种TaskScheduler，有些同学可能想问，这些Scheduler我用起来不爽，我想自定义一下，这个可

以吗？当然！！！如果你想自定义，只要自定义一个类实现一下TaskScheduler就可以了，然后你可以将ThreadPoolTaskScheduler简化一下，即我要

求所有的Task都需要走Thread，杜绝使用TheadPool，这样可以吗，当然了，不信你看。

namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            var task = Task.Factory.StartNew(() =>
            {
                Console.WriteLine("hello world！！！");
            }, new CancellationToken(), TaskCreationOptions.None, new PerThreadTaskScheduler());

            Console.Read();
        }
    }

    /// <summary>
    /// 每个Task一个Thread
    /// </summary>
    public class PerThreadTaskScheduler : TaskScheduler
    {
        protected override IEnumerable<Task> GetScheduledTasks()
        {
            return null;
        }

        protected override void QueueTask(Task task)
        {
            var thread = new Thread(() =>
            {
                TryExecuteTask(task);
            });

            thread.Start();
        }

        protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
        {
            throw new NotImplementedException();
        }
    }
}

方法的使用

TaskScheduler.FromCurrentSynchronizationContext（） 方法

创建一个与当前SynchronizationContext关联的TaskScheduler。源代码如下：

假设有一个UI App，它有一个按钮。当点击按钮后，会从网上下载一些文本并将其设置为按钮的内容。我们应当只在UI线程中访问该按钮，因此当我们成功下载新的文本后，我们需要从拥有按钮控制权的的线程中将其设置为按钮的内容。如果不这样做的话，会得到一个这样的异常：

System.InvalidOperationException: 'The calling thread cannot access this object because a different thread owns it.'

如果我们自己手动实现，那么可以使用前面所述的SynchronizationContext将按钮内容的设置传回原始上下文，例如借助TaskScheduler：

用法如下

private static readonly HttpClient s_httpClient = new HttpClient();

private void downloadBtn_Click(object sender, RoutedEventArgs e)
{
    s_httpClient.GetStringAsync("http://example.com/currenttime").ContinueWith(downloadTask =>
    {
        downloadBtn.Content = downloadTask.Result;
    }, TaskScheduler.FromCurrentSynchronizationContext());//捕获当前UI线程的同步上下文
}