異步編程（async&await）

時間 2019-12-19

標籤異步編程 async&await async await 欄目 Java 简体版

原文原文鏈接

前言

原本這篇文章上個月就該發佈了，可是由於忙 QuarkDoc 一直沒有時間整理，因此耽擱到今天，如今迴歸正軌。html

C# 5.0 雖然只引入了2個新關鍵詞：async和await。然而它大大簡化了異步方法的編程。web

在線程池（threadPool）大體介紹了微軟在不一樣時期使用的不一樣的異步模式，有3種：數據庫

1.異步模式編程

2.基於事件的異步模式併發

3.基於任務的異步模式（TAP）異步

而最後一種就是利用async和await關鍵字來實現的（TAP是如今微軟極力推崇的一種異步編程方式）。async

但請謹記，async和await關鍵字只是編譯器功能。編譯器會用Task類建立代碼。若是不使用這兩個關鍵詞，用C#4.0的Task類一樣能夠實現相同的功能，只是沒有那麼方便而已。ide

認識async和await

使用async和await關鍵詞編寫異步代碼，具備與同步代碼至關的結構和簡單性，而且摒棄了異步編程的複雜結構。異步編程

可是在理解上剛開始會很不習慣，並且會把一些狀況想固然了，而真實狀況會相去甚遠（我犯過這樣的錯誤）。因此根據幾個示例一步步理解更加的靠譜些。性能

1.一個簡單的同步方法

這是一個簡單的同步方法調用示例：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Console.WriteLine($"頭部已執行，當前主線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
 6             string result = SayHi("jack");
 7             Console.WriteLine(result);
 8             Console.WriteLine($"尾部已執行，當前主線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
 9             Console.ReadKey();
10         }
11         static string SayHi(string name)
12         {
13             Task.Delay(2000).Wait();//異步等待2s
14             Console.WriteLine($"SayHi執行，當前線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
15             return $"Hello,{name}";
16         }
17     }

執行結果以下，方法在主線程中運行，主線程被阻塞。

2.同步方法異步化

示例將方法放到任務內執行：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Console.WriteLine($"頭部已執行，當前主線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
 6             string result = SayHiAsync("jack").Result;
 7             Console.WriteLine(result);
 8             Console.WriteLine($"尾部已執行，當前主線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
 9             Console.ReadKey();
10         }
11         static Task<string> SayHiAsync(string name)
12         {
13             return Task.Run<string>(() => { return SayHi(name); });
14         }
15         static string SayHi(string name)
16         {
17             Task.Delay(2000).Wait();//異步等待2s
18             Console.WriteLine($"SayHi執行，當前線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
19             return $"Hello,{name}";
20         }
21     }

執行結果以下，方法在另一個線程中運行，由於主線程調用了Result，Result在任務沒有完成時內部會使用Wait，因此主線程仍是會被阻塞。

3.延續任務

示例爲了不阻塞主線程使用任務延續的方式：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Console.WriteLine($"頭部已執行，當前主線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
 6             Task<string> task = SayHiAsync("jack");
 7             task.ContinueWith(t =>//延續任務，指定任務執行完成後延續的操做
 8             {
 9                 Console.WriteLine($"延續執行，當前線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
10                 string result = t.Result;
11                 Console.WriteLine(result);
12             });
13             Console.WriteLine($"尾部已執行，當前主線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
14             Console.ReadKey();
15         }
16         static Task<string> SayHiAsync(string name)
17         {
18             return Task.Run<string>(() => { return SayHi(name); });
19         }
20         static string SayHi(string name)
21         {
22             Task.Delay(2000).Wait();//異步等待2s
23             Console.WriteLine($"SayHi執行，當前線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
24             return $"Hello,{name}";
25         }
26     }

執行結果以下，方法在另一個線程中運行，由於任務附加了延續，延續會在任務完成後處理返回值，而主線程不會被阻塞。這應該就是想要的效果了。

4.使用async和await構建異步方法調用

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Console.WriteLine($"頭部已執行，當前主線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
 6             CallerWithAsync("jack");
 7             Console.WriteLine($"尾部已執行，當前主線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
 8             Console.ReadKey();
 9         }
10         async static void CallerWithAsync(string name)
11         {
12             Console.WriteLine($"異步調用頭部執行，當前線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
13             string result = await SayHiAsync(name);
14             Console.WriteLine($"異步調用尾部執行，當前線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
15             Console.WriteLine(result);
16         }
17         static Task<string> SayHiAsync(string name)
18         {
19             return Task.Run<string>(() => { return SayHi(name); });
20         }
21         static string SayHi(string name)
22         {
23             Task.Delay(2000).Wait();//異步等待2s
24             Console.WriteLine($"SayHi執行，當前線程Id爲：{Thread.CurrentThread.ManagedThreadId}");
25             return $"Hello,{name}";
26         }
27     }

執行結果以下，使用await關鍵字來調用返回任務的異步方法SayHiAsync，而使用await須要有用async修飾符聲明的方法，在SayHiAsync方法爲完成前，下面的方法不會繼續執行。可是主線程並無阻塞，且任務處理完成後await後的邏輯繼續執行。

本質：編譯器將await關鍵字後的全部代碼放進了延續（ContinueWith）方法的代碼塊中來轉換await關鍵詞。

解析async和await

1.異步（async）

使用async修飾符標記的方法稱爲異步方法，異步方法只能夠具備如下返回類型：
1.Task
2.Task<TResult>
3.void
4.從C# 7.0開始，任何具備可訪問的GetAwaiter方法的類型。System.Threading.Tasks.ValueTask<TResult> 類型屬於此類實現（需向項目添加System.Threading.Tasks.Extensions NuGet 包）。

異步方法一般包含 await 運算符的一個或多個實例，但缺乏 await 表達式也不會致使生成編譯器錯誤。若是異步方法未使用 await 運算符標記暫停點，那麼異步方法會做爲同步方法執行，即便有 async 修飾符也不例外，編譯器將爲此類方法發佈一個警告。

2.等待（await）

await 表達式只能在由 async 修飾符標記的封閉方法體、lambda 表達式或異步方法中出現。在其餘位置，它會解釋爲標識符。

使用await運算符的任務只可用於返回 Task、Task<TResult> 和 System.Threading.Tasks.ValueType<TResult> 對象的方法。

異步方法同步運行，直至到達其第一個 await 表達式，此時await在方法的執行中插入掛起點，會將方法掛起直到所等待的任務完成，而後繼續執行await後面的代碼區域。

await 表達式並不阻止正在執行它的線程。而是使編譯器將剩下的異步方法註冊爲等待任務的延續任務。控制權隨後會返回給異步方法的調用方。任務完成時，它會調用其延續任務，異步方法的執行會在暫停的位置處恢復。

注意：

1.沒法等待具備 void 返回類型的異步方法，而且無效返回方法的調用方捕獲不到異步方法拋出的任何異常。

2.異步方法沒法聲明 in、ref 或 out 參數，但能夠調用包含此類參數的方法。一樣，異步方法沒法經過引用返回值，但能夠調用包含 ref 返回值的方法。

異步方法運行機理（控制流）

異步編程中最需弄清的是控制流是如何從方法移動到方法的。

下列示例及說明引自（官方文檔），我的認爲已經很清晰了：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             var result = AccessTheWebAsync();
 6             Console.ReadKey();
 7         }
 8         async static Task<int> AccessTheWebAsync()
 9         {
10             HttpClient client = new HttpClient();
11             // GetStringAsync返回一個任務。任務Result會獲得一個字符串(urlContents)。
12             Task<string> getStringTask = client.GetStringAsync("https://www.cnblogs.com/jonins/");
13             //您能夠在這裏完成不依賴於GetStringAsync的字符串的工做。
14             DoIndependentWork();
15             //等待的操做員暫停進入WebAsync。
16             //AccessTheWebAsync在getStringTask完成以前不能繼續。
17             //同時，控制權返回到AccessTheWebAsync的調用方。
18             //當getStringTask完成後，控件權將繼續在這裏工做。 而後，await運算符從getStringTask檢索字符串結果。 
19             string urlContents = await getStringTask;
20             //任務完成
21             Console.WriteLine(urlContents.Length);
22             //return語句指定一個整數結果。 
23             return urlContents.Length;
24         }
25         static void DoIndependentWork()
26         {
27             Console.WriteLine("Working..........");
28         }
29     }

多個異步方法

在一個異步方法裏，能夠調用一個或多個異步方法，如何編碼取決於異步方法間結果是否相互依賴。

1.順序調用異步方法

使用await關鍵詞能夠調用每一個異步方法，若是一個異步方法須要使用另外一個異步方法的結果，await關鍵詞就很是必要。

示例以下：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Console.WriteLine("執行前.....");
 6             GetResultAsync();
 7             Console.WriteLine("執行中.....");
 8             Console.ReadKey();
 9         }
10         async static void GetResultAsync()
11         {
12             var number1 = await GetResult(10);
13             var number2 =  GetResult(number1);
14             Console.WriteLine($"結果分別爲：{number1}和{number2.Result}");
15         }
16         static Task<int> GetResult(int number)
17         {
18             return Task.Run<int>(() => { Task.Delay(1000).Wait(); return number + 10; });
19         }
20     }

2.使用組合器

若是異步方法間相互不依賴，則每一個異步方法都不使用await，而是把每一個異步方法的結果賦值給Task變量，就會運行得更快。

示例以下：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Console.WriteLine("執行前.....");
 6             GetResultAsync();
 7             Console.WriteLine("執行中.....");
 8             Console.ReadKey();
 9         }
10         async static void GetResultAsync()
11         {
12             Task<int> task1 = GetResult(10);
13             Task<int> task2 = GetResult(20);
14             await Task.WhenAll(task1, task2);
15             Console.WriteLine($"結果分別爲：{task1.Result}和{task2.Result}");
16         }
17         static Task<int> GetResult(int number)
18         {
19             return Task.Run<int>(() => { Task.Delay(1000).Wait(); return number + 10; });
20         }
21     }

Task類定於2個組合器分別爲：WhenAll和WhenAny。

WhenAll是在全部傳入的任務都完成時才返回Task。

WhenAny是在傳入的任務其中一個完成就會返回Task。

異步方法的異常處理

1.異常處理

如下示例一種是普通的錯誤的捕獲方式，另外一種是異步方法異常捕獲方式：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5 
 6             DontHandle();
 7             HandleError();
 8             Console.ReadKey();
 9         }
10         //錯誤處理
11         static void DontHandle()
12         {
13             try
14             {
15                 var task = ThrowAfter(0, "DontHandle Error");
16             }
17             catch (Exception ex)
18             {
19 
20                 Console.WriteLine(ex.Message);
21             }
22         }
23         //異步方法錯誤處理
24         static async void HandleError()
25         {
26             try
27             {
28                 await ThrowAfter(2000, "HandleError Error");
29             }
30             catch (Exception ex)
31             {
32 
33                 Console.WriteLine(ex.Message);
34             }
35         }
36         //在延遲後拋出異常
37         static async Task ThrowAfter(int ms, string message)
38         {
39             await Task.Delay(ms);
40             throw new Exception(message);
41         }
42     }

執行結果以下：

調用異步方法，若是隻是簡單的放在try/catch塊中，將會捕獲不到異常。這是由於DontHandle方法在ThrowAfter拋出異常以前已經執行完畢（返回void的異步方法不會等待。這是由於從async void方法拋出的異常沒法捕獲。所以異步方法最好返回一個Task類型）。

異步方法的一個較好異常處理方式，是使用await關鍵字，將其放在try/catch中。

2.多個異步方法異常處理

若是調用了多個異步方法，在第一個異步方法拋出異常，後續的方法將不會被調用，catch塊內只會處理出現的第一個異常。

因此正確的作法是使用Task.WhenAll,無論任務是否拋出異常都會等到全部任務完成。Task.WhenAll結束後，異常被catch語句捕獲到。若是隻是捕獲Exception，咱們只能看到WhenAll方法的第一個發生異常的任務信息，不會拋出後續的異常任務。

若是要捕獲全部任務的異常信息，就是對任務聲明變量，在catch塊內能夠訪問，再使用IsFaulted屬性檢查任務的狀態，以確認它們是否出現錯誤，而後再進行處理。示例以下：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             HandleError();
 6             Console.ReadKey();
 7         }
 8         //正確的處理方式
 9         static async void HandleError()
10         {
11             Task t1 = null;
12             Task t2 = null;
13             try
14             {
15                 t1 = ThrowAfter(1000, "HandleError-One-Error");
16                 t2 = ThrowAfter(2000, "HandleError-Two-Error");
17                 await Task.WhenAll(t1, t2);
18             }
19             catch (Exception)
20             {
21                 if (t1.IsFaulted)
22                     Console.WriteLine(t1.Exception.InnerException.Message);
23                 if (t2.IsFaulted)
24                     Console.WriteLine(t2.Exception.InnerException.Message);
25             }
26         }
27         //在延遲後拋出異常
28         static async Task ThrowAfter(int ms, string message)
29         {
30             await Task.Delay(ms);
31             throw new Exception(message);
32         }
33     }

3.使用AggregateException捕獲異步方法異常

在 任務（task）中介紹過AggregateException，它包含了等待中全部異常的列表，可輕鬆遍歷處理全部異常信息。示例以下：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             HandleError();
 6             Console.ReadKey();
 7         }
 8         //正確的處理方式
 9         static async void HandleError()
10         {
11             Task taskResult = null;
12             try
13             {
14                 Task t1 = ThrowAfter(1000, "HandleError-One-Error");
15                 Task t2 = ThrowAfter(2000, "HandleError-Two-Error");
16                 await (taskResult = Task.WhenAll(t1, t2));
17             }
18             catch (Exception)
19             {
20                 foreach (var ex in taskResult.Exception.InnerExceptions)
21                 {
22                     Console.WriteLine(ex.Message);
23                 }
24           
25             }
26         }
27         //在延遲後拋出異常
28         static async Task ThrowAfter(int ms, string message)
29         {
30             await Task.Delay(ms);
31             throw new Exception(message);
32         }
33     }

重要的補充與建議

1.提升響應能力

.NET有不少異步API咱們均可以經過async/await構建調用提升響應能力，例如：

 1     class Program
 2     {
 3         static void Main(string[] args)
 4         {
 5             Demo();
 6             Console.ReadKey();
 7         }
 8         static async void Demo()
 9         {
10             HttpClient httpClient = new HttpClient();
11             var getTaskResult = await httpClient.GetStringAsync("https://www.cnblogs.com/jonins/");
12             Console.WriteLine(getTaskResult);
13         }
14     }

這些API都有相同原則即以Async結尾。

2.重要建議

1.async方法需在其主體中具備await 關鍵字，不然它們將永不暫停。同時C# 編譯器將生成一個警告，此代碼將會以相似普通方法的方式進行編譯和運行。請注意這會致使效率低下，由於由 C# 編譯器爲異步方法生成的狀態機將不會完成任何任務。

2.應將「Async」做爲後綴添加到所編寫的每一個異步方法名稱中。這是 .NET 中的慣例，以便更輕鬆區分同步和異步方法。

3.async void 應僅用於事件處理程序。由於事件不具備返回類型（所以沒法返回 Task 和 Task<T>）。其餘任何對 async void 的使用都不遵循 TAP 模型，且可能存在必定使用難度。

例如：async void 方法中引起的異常沒法在該方法外部被捕獲或十分難以測試 async void 方法。

3.以非阻止方式處理等待任務

異步編程準則

異步編程的準則是肯定所需執行的操做是I/O-Bound仍是 CPU-Bound。由於這會極大影響代碼性能，並可能致使某些構造的誤用。

考慮兩個問題：

1.你的代碼是否會「等待」某些內容，例如數據庫中的數據或web資源等？若是答案爲「是」，則你的工做是 I/O-Bound。

2.你的代碼是否要執行開銷巨大的計算？若是答案爲「是」，則你的工做是 CPU-Bound。

若是你的工做爲 I/O-Bound，請使用 async 和 await（而不使用 Task.Run）。不該使用任務並行庫。
若是你的工做爲 CPU-Bound，而且你重視響應能力，請使用 async 和 await，並在另外一個線程上使用 Task.Run 生成工做。若是該工做同時適用於併發和並行，則應考慮使用任務並行庫。