C# 異步編程

     基于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之后的代碼；直白點的意思就是async/await就是一個讓編譯器把現有的代碼直接生成一個帶回呼邏輯代碼的語法糖，

     先添加一個方法，如下：

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

     接著添加按鈕事件方法：

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 }

 8.異步性能

異步方法是一個功能強大的高效工具，使您能夠更輕松撰寫可伸縮和回應更快的庫和應用程式， 請牢記一點，異步不是對單個操作的性能優化， 采用同步操作并使其異步化必然會降低該操作的性能，因為它仍然需要完成同步操作的所有作業，只不過現在會有額外的限制和注意事項， 關注異步的一個原因是其總體性能：如果采用異步方法撰寫所有內容，整個系統的執行效果如何，這樣僅消耗執行需要的有價值的資源，重疊 I/O 并實作更好的系統利用率，從現在開始，無論何時準備在 .NET Framework 中開發異步代碼，異步方法都是首選的工具， 

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

標籤：C#

上一篇：C# 添加Word水印（基于Spire.Cloud.SDK for .NET ）

下一篇：(求救)mysql.data.mysqlclient的資料提供程式，無法獲得提供程式工廠