用慣了Task，你應該也需要瞭解它的內部調度機制TaskScheduler

　　平時我們在用多線程開發的時候少不了Task，確實task給我們帶來了巨大的編程效率，在Task底層有一個TaskScheduler，它決定了task該如何被調度，而

在.net framework中有兩種系統定義Scheduler，第一個是Task預設的ThreadPoolTaskScheduler，還是一種就是SynchronizationContextTaskScheduler，

以及這兩種類型之外的如何自定義，這篇剛好和大家分享一下。

一: ThreadPoolTaskScheduler

      這種scheduler機制是task的預設機制，而且從名字上也可以看到它是一種委托到ThreadPool的機制，剛好也從側面說明task是基於ThreadPool基礎上的

封裝，如果想具體查看代碼邏輯，你可以通過ILSpy反編譯一下代碼看看：

 1   protected internal override void QueueTask(Task task)
 2          {
 3              if ((task.Options & TaskCreationOptions.LongRunning) != TaskCreationOptions.None)
 4              {
 5                  new Thread(ThreadPoolTaskScheduler.s_longRunningThreadWork)
 6                  {
 7                      IsBackground = true
 8                  }.Start(task);
 9                  return;
10              }
11              bool forceGlobal = (task.Options & TaskCreationOptions.PreferFairness) > TaskCreationOptions.None;
12              ThreadPool.UnsafeQueueCustomWorkItem(task, forceGlobal);
13          }

       從上面的代碼中可以看到如下邏輯，如果當前Task上的TaskCreationOptions設置為LongRunning的話，這個task就會委托到Thread中去執行，這樣的

好處顯而易見，如果長時間運行的task占用著ThreadPool的線程，這時候ThreadPool為了保證線程充足，會再次開闢一些Thread，如果耗時任務此時釋放了，

會導致ThreadPool線程過多，上下文切換頻繁，所以這種情況下讓Task在Thread中執行還是非常不錯的選擇，當然如果你不指定這個LongRunning的話，那就

是在ThreadPool上執行，不信的話，還可以用windbg去驗證一下。。。

1     static void Main(string[] args)
2          {
3              var task = Task.Factory.StartNew(() =>
4              {
5                  Console.WriteLine("hello world！！！");
6              }, TaskCreationOptions.LongRunning);
7  
8              Console.Read();
9          }

如果大家對windbg不熟悉的話，也沒關係，先暫且不討論，我們只要把TaskCreationOptions枚舉去掉，然後用這種形式的!threads給大家展示下不同

應該就非常明朗了。

1        static void Main(string[] args)
2          {
3              var task = Task.Factory.StartNew(() =>
4              {
5                  Console.WriteLine("hello world！！！");
6              });
7  
8              Console.Read();
9          }

好了，當你看到這兩張圖，你應該明白帶LongRunning的話，thread中沒有帶（ThreadPool Worker）標記，也就表明當前是單獨開闢的線程，而下麵

這張圖很明顯帶有這種標識，表示當前是委托在ThreadPool中執行的。

二：SynchronizationContextTaskScheduler

     從這個名字中就可以看到，這是一個同步上下文的taskscheduler，原理就是把繁重的耗時工作丟給ThreadPool，然後將更新UI的操作丟給 UI線程的

隊列中，由UIThread來執行，具體的也可以在這種scheduler中窺得一二。

1        protected internal override void QueueTask(Task task)
2          {
3              this.m_synchronizationContext.Post(SynchronizationContextTaskScheduler.s_postCallback, task);
4          }

     然後可以從s_postCallback上看到裡面有一個Invoke函數，如下圖：

1  public virtual void Post(SendOrPostCallback d, object state)
2  {
3      ThreadPool.QueueUserWorkItem(new WaitCallback(d.Invoke), state);
4  }

      有了這個基礎我們再來看一下代碼怎麼寫，可以看到，下麵這段代碼是不阻塞UIThread的，完美~~~

 1          private void button1_Click(object sender, EventArgs e)
 2          {
 3              Task task = Task.Factory.StartNew(() =>
 4              {
 5                  //複雜操作，等待10s
 6                  Thread.Sleep(10000);
 7  
 8              }).ContinueWith((t) =>
 9              {
10                  button1.Text = "hello world";
11              }, TaskScheduler.FromCurrentSynchronizationContext());
12          }

三：自定義TaskScheduler　

　　我們知道在現有的.net framework中只有這麼兩種TaskScheduler，有些同學可能想問，這些Scheduler我用起來不爽，我想自定義一下，這個可

以嗎？當然！！！如果你想自定義，只要自定義一個類實現一下TaskScheduler就可以了，然後你可以將ThreadPoolTaskScheduler簡化一下，即我要

求所有的Task都需要走Thread，杜絕使用TheadPool，這樣可以嗎，當然了，不信你看。

 1 namespace ConsoleApplication1
 2 {
 3     class Program
 4     {
 5         static void Main(string[] args)
 6         {
 7             var task = Task.Factory.StartNew(() =>
 8             {
 9                 Console.WriteLine("hello world！！！");
10             }, new CancellationToken(), TaskCreationOptions.None, new PerThreadTaskScheduler());
11 
12             Console.Read();
13         }
14     }
15 
16     /// <summary>
17     /// 每個Task一個Thread
18     /// </summary>
19     public class PerThreadTaskScheduler : TaskScheduler
20     {
21         protected override IEnumerable<Task> GetScheduledTasks()
22         {
23             return null;
24         }
25 
26         protected override void QueueTask(Task task)
27         {
28             var thread = new Thread(() =>
29             {
30                 TryExecuteTask(task);
31             });
32 
33             thread.Start();
34         }
35 
36         protected override bool TryExecuteTaskInline(Task task, bool taskWasPreviouslyQueued)
37         {
38             throw new NotImplementedException();
39         }
40     }
41 }

  看到沒有，自定義Task就是這麼簡單，其實自定義操作中最重要的就是其中的QueueTask方法，接下來我可以用windbg觀察一下，確實是工作線程，而不是

線程池，沒騙你~~~

好了，本篇就說到這裡，希望對你有幫助。