基於Task的非同步程式設計模式（TAP）是Microsoft為.Net平臺下使用Task進行程式設計所提供的一組建議，這種模式提供了可以被await消耗（呼叫）方法的APIs，並且當使用async關鍵字編寫遵守這種模式的方法時，手寫Task通常很有用。通常TAP用起來與普通方式沒什麼兩樣，但是不支援ref和out引數。

     任務和執行緒的區別：
     1、任務是架構線上程之上的，也就是說任務最終還是要拋給執行緒去執行。

     2、任務跟執行緒不是一對一的關係，比如開10個任務並不是說會開10個執行緒，這一點任務有點類似執行緒池，但是任務相比執行緒池有很小的開銷和精確的控制。

     3、Task的優勢

　　ThreadPool相比Thread來說具備了很多優勢，但是ThreadPool卻又存在一些使用上的不方便。比如：
　　◆ ThreadPool不支援執行緒的取消、完成、失敗通知等互動性操作；
　　◆ ThreadPool不支援執行緒執行的先後次序；
     以往，如果開發者要實現上述功能，需要完成很多額外的工作，現在，微軟提供了一個功能更強大的概念：Task。Task線上程池的基礎上進行了優化，並提供了更多的API。

 下面分析一理非同步程式設計中的一些關鍵點

1.await  

     我們都知道await關鍵字是.Net FrameWork4.5引入的特性。await使得我們使用非同步更加時特別便捷，並且還不會導致執行緒堵塞。我們在使用時也就莫名其妙的使用。往往不知道為什麼不會導致執行緒堵塞。在這裡，簡單的談論下await的一點原理。

     在c#並行程式設計這本書中是這麼介紹await的：async方法在開始時以同步方式執行,在async方法內部,await關鍵字對它引數執行一個非同步等待,它首先檢查操作是否已經完成,如果完成,就繼續執行(同步方式),否則,會暫停async方法,並返回.留下一個未完成的task，一段時間後,操作完成,async方法就恢復執行.

     看到這句話應該就差不多能想到await為什麼不會導致執行緒堵塞了，當碰到await時如果沒有執行成功就先暫停這個方法的執行，執行方法外以下程式碼，等await操作完成後再執行這個方法await之後的程式碼。

1 private  void button1_Click(object sender, EventArgs e)
2 {
3       DemoAsync();
4       MessageBox.Show("同步程式碼");
5 }

     執行後會發現在點選button按鈕時窗體不能被移動了,然後等待了3秒鐘才彈出"同步程式碼"這句話。

1 async Task DemoAsync()
2 {
3       await Task.Run(() => { Thread.Sleep(3000); });
4       Thread.Sleep(3000);
5 }

     再次執行就會神奇的發現,此時會先彈出"同步程式碼"這局話,然後等待3秒後窗體就不能被移動。

2.Task

     Task 類表示通常以非同步方式執行的單個操作， Task 物件是基於任務的非同步模式的中心元件之一。 由於 Task 物件執行的工作通常線上程池執行緒上非同步執行，而不是在主應用程式執行緒上同步執行，因此可以使用 Status 屬性，還可以使用 IsCanceled、IsCompleted和 IsFaulted 屬性，用於確定任務的狀態。 通常，lambda 表示式用於指定任務要執行的工作。可以通過多種方式建立 Task 例項。 最常見的方法（從 .NET Framework 4.5開始提供）是呼叫靜態 Run 方法。 Run 方法提供一種簡單的方法來使用預設值啟動任務，而無需其他引數。Task 類還提供了初始化任務的建構函式，但不計劃執行該任務。 出於效能原因，Task.Run 或 TaskFactory.StartNew 方法是用於建立和計劃計算任務的首選機制，但對於必須分隔建立和計劃的情況，可以使用建構函式，然後呼叫 Task.Start用於計劃任務稍後執行的方法。因為任務通常線上程池執行緒上以非同步方式執行，所以，建立和啟動任務的執行緒會在例項化任務後立即繼續執行。 在某些情況下，當呼叫執行緒是主應用程式執行緒時，應用程式可能會在任何任務實際開始執行之前終止。 在其他情況下，應用程式的邏輯可能要求呼叫執行緒在一個或多個任務完成執行時繼續執行。 可以通過呼叫 Wait 方法來等待一個或多個任務完成，從而同步呼叫執行緒的執行以及它啟動的非同步任務。若要等待單個任務完成，可以呼叫其 Task.Wait 方法。 Wait(Int32) 和 Wait(TimeSpan) 方法會阻止呼叫執行緒，直到任務完成或超時間隔結束。

     需要注意的是，Task中的方法一般是不會將異常丟擲的，哪怕是Task<T>這種，這需要開發人員自行處理。不過如果獲取Task<T>.Result則會將任務內的異常丟擲來；

 1 public static async Task<string> Hello(int a=0)
 2 {
 3     return await Task.Run(async () =>
 4     {
 5         await Task.Delay(1000).ConfigureAwait(true);
 6 
 7         return $"Hello {10/a}";
 8 
 9     }).ConfigureAwait(true);
10 }
11 //不會報異常
12 Hello(0);
13 //會報異常
14 var a1=  Hello(0).Result;

Task.Factory提供了更多引數的Task建立方式以支援自定義的Task，比如：Task,Factory.StartNew(Action action, CancellationToken cancellationToken, TaskCreationOptions creationOptions, TaskScheduler scheduler)就支援指定取消通知引數、任務建立模式，指定任務排程器；其中TaskCreationOptions引數意義如下：

3.Task.ConfigureAwait

     在Task裡中有ConfigureAwait這麼一個方法,這個方法是幹什麼的呢,我們先看下方法註釋是怎麼解釋這個方法的：" 嘗試將延續任務封送回原始上下文，則為 true；否則為 false。"  光看這段程式碼並看不出什麼，然後我們再看這麼一段話："一個async方法是由多個同步執行的程式塊組成.每個同步程式塊之間由await語句分隔.用await語句等待一個任務完成.當該方法在await處暫停時,就可以捕捉上下文(context).如果當前SynchronizationContext不為空,這個上下文就是當前SynchronizationContext.如果為空,則這個上下文為當前TaskScheduler.該方法會在這個上下文中繼續執行.一般來說,執行UI執行緒時採用UI上下文,處理ASP.NET請求時採用ASP.NET請求上下文,其它很多情況則採用執行緒池上下文。" 這句話已經基本講明瞭其實後續程式碼會下上文中執行。這個上下文一般時UI上下文（執行在UI上）或請求上下文（ASP.NET) 這兩個可以說時原始上下文，而其它情況採用執行緒池上下文，也就是開闢一個新執行緒。這麼說也就是ConfigureAwait方法是將後續程式碼是送到原始上下文還是執行緒池上下文中。

     下面稍微修改下剛才的方法：

1 async Task DemoAsync()
2 {
3      //將後續程式碼交給執行緒池執行
4      await Task.Run(() => { Thread.Sleep(3000); }).ConfigureAwait(false);
5      Thread.Sleep(3000);
6 }

     ConfigureAwait(false)將後續程式碼交給執行緒池來執行,也就是上面的Thread.Sleep並不會阻塞窗體。

4.Task.Delay

     在非同步程式設計中，一般不建議使用Thread.Sleep，而是使用粒度更小的Task.Delay；Thread.Sleep、Thread.Yeild等會讓當前工作執行緒阻塞，而Task.Delay可以讓當前執行緒空出來去完成其他的Task。

 1       CancellationTokenSource source = new CancellationTokenSource();
 2 
 3       var t = Task.Run(async delegate
 4               {
 5                  await Task.Delay(TimeSpan.FromSeconds(1.5), source.Token);
 6                  return 42;
 7               });
 8       source.Cancel();
 9       try {
10          t.Wait();
11       }
12       catch (AggregateException ae) {
13          foreach (var e in ae.InnerExceptions)
14             Console.WriteLine("{0}: {1}", e.GetType().Name, e.Message);
15       }

5.SemaphoreSlim

     表示對可同時訪問資源或資源池的執行緒數加以限制的 Semaphore 的輕量替代， SemaphoreSlim類是用於在單個應用內進行同步的建議訊號量。在非同步程式設計過程中，建議使用SemaphoreSlim.Wait()、SemaphoreSlim.Release()來替換Lock，因為lock只能由當前執行緒來解鎖，而SemaphoreSlim可以由任意執行緒來解鎖。

6.CancellationTokenSource 

     啟動一個Task去做一些事，如果希望它在某個階段去被動的停止，可以使用這個CancellationTokenSource物件，把它注入到Task裡，使用當外界觸發Cancel()方法或設定了超時時，這個Task就會被取消。通常和CancellationToken.IsCancellationRequested一起配合Task來使用。

 1         public static async void Loop(int timeOut = 5 * 1000)
 2         {
 3             using (CancellationTokenSource source = new CancellationTokenSource(timeOut))
 4             {
 5                 CancellationToken token = source.Token;
 6 
 7                 //匿名非同步方法
 8                 var task1 = Task.Run(async () =>
 9                 {
10                     while (!token.IsCancellationRequested)
11                     {
12                         Console.WriteLine($"{DateTime.Now.ToLongTimeString()}\t TaskTest Loop");
13                         await Task.Delay(1000).ConfigureAwait(false);
14                     }
15                     Console.WriteLine($"{DateTime.Now.ToLongTimeString()}\t TaskTest Loop Timeout Stoped");
16                 }, token);
17 
18                 await Task.WhenAll(task1).ConfigureAwait(false);
19             }
20         }

     也可以CancellationTokenSource.CreateLinkedTokenSource來關聯多個CancellationTokenSource

 1 using (CancellationTokenSource cts = new CancellationTokenSource())
 2 {
 3     var cancellationToken = cts.Token;
 4 
 5     using (CancellationTokenSource timeoutSource = new CancellationTokenSource(timeOut * 1000))
 6 
 7     using (CancellationTokenSource linkSource = CancellationTokenSource.CreateLinkedTokenSource(timeoutSource.Token, cancellationToken))
 8     {
 9         var task = Task.Run(() =>
10         {
11             ...
12         }, linkSource.Token);
13 
14         //引發非同步異常
15         if (a == 10)
16         {
17             cts.Cancel();
18         }
19 
20         return await task2.ConfigureAwait(true);
21     }
22 }

 7.TaskCompletionSource

表示未繫結到委託的 Task<TResult> 的製造者方，並通過 Task 屬性提供對使用者方的訪問。從這個官方解釋上看不出這個到底有什麼作用，其實這是一種受用者控制建立Task的方式。你可以使Task在任何你想要的時候完成，你也可以在任何地方給它一個異常讓它失敗。這個可以實現事件通知類似的功能；具體就是說TaskCompletionSource如果不進行SetResult或SetException的時候，TaskCompletionSource所委託的的Task是不會有Result,這個Task會一直等待TaskCompletionSource來賦值；這樣就極大的簡化了非同步事件或非同步通知的實現。

 1 public static async Task<int> SetValue(int a = 1)
 2 {
 3     var sw = Stopwatch.StartNew();
 4 
 5     TaskCompletionSource<int> tcs = new TaskCompletionSource<int>();
 6 
 7     await Task.Run(async () =>
 8     {
 9         try
10         {
11             await Task.Delay(10 * 1000).ConfigureAwait(true);
12             //此處若不賦值，測tcs.Task.Result會一直等待
13             tcs.SetResult(10 / a);
14         }
15         catch (Exception ex)
16         {
17             tcs.SetException(ex);
18         }
19     }).ConfigureAwait(true);
20 
21 
22     return await Task.Run(() =>
23     {
24         int result = 0;
25         try
26         {
27             result = tcs.Task.Result;
28 
29             Console.WriteLine("tcs取值成功！");
30         }
31         catch (AggregateException e)
32         {
33             Console.WriteLine("tcs異常");
34 
35             for (int j = 0; j < e.InnerExceptions.Count; j++)
36             {
37                 Console.WriteLine($"\n-------------------------------------------------\n{e.InnerExceptions[j].ToString()}\n-------------------------------------------------\n");
38             }
39         }
40         sw.Stop();
41         Console.WriteLine($"(ElapsedTime={sw.ElapsedMilliseconds})");
42         return result;
43     }).ConfigureAwait(true);
44 }

轉載請標明本文來源：https://www.cnblogs.com/yswenli/p/11987377.html
更多內容歡迎我的的github：https://github.com/yswenli
如果發現本文有什麼問題和任何建議，也隨時歡迎交流~