第十五節：深刻理解async和await的做用及各類適用場景和用法

時間 2019-11-10

標籤第十五深刻理解 async await 各類適用場景用法欄目 Java 简体版

原文原文鏈接

一. 同步VS異步html

1. 同步 VS 異步 VS 多線程編程

同步方法：調用時須要等待返回結果，才能夠繼續往下執行業務

異步方法：調用時無須等待返回結果，能夠繼續往下執行業務

開啓新線程：在主線程以外開啓一個新的線程去執行業務

同步方法和異步方法的本質區別：調用時是否須要等待返回結果才能繼續執行業務

2. 常見的異步方法（都以Async結尾）json

　　① HttpClient類：PostAsync、PutAsync、GetAsync、DeleteAsyncapi

　　② EF中DbContext類：SaveChangesAsync跨域

　　③ 文件相關中的：WriteLineAsync服務器

3. 引入異步方法的背景多線程

　　好比我在後臺要向另外一臺服務器中獲取中的2個接口獲取信息，而後將兩個接口的信息拼接起來，一塊兒輸出，接口1耗時3s，接口2耗時5s，app

① 傳統的同步方式：異步

　　須要的時間大約爲：3s + 5s =8s, 以下面 【案例1】async

先分享一個同步請求接口的封裝方法，下同。

 1   public class HttpService
 2     {
 3         /// <summary>
 4         /// 後臺跨域請求發送代碼
 5         /// </summary> 
 6         /// <param name="url">eg:http://ac.guojin.org/jeesite/regist/saveAppAgentAccount </param>
 7         ///<param name="postData"></param>
 8         ///  參數格式（手拼Json） string postData = "{\"name\":\"" + vip.comName + "\",\"shortName\":\"" + vip.shortName + + "\"}";             
 9         /// <returns></returns>
10         public static string PostData(string postData, string url)
11         {
12             HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);//後臺請求頁面
13             Encoding encoding = Encoding.GetEncoding("utf-8");//注意頁面的編碼，不然會出現亂碼
14             byte[] requestBytes = encoding.GetBytes(postData);
15             req.Method = "POST";
16             req.ContentType = "application/json";
17             req.ContentLength = requestBytes.Length;
18             Stream requestStream = req.GetRequestStream();
19             requestStream.Write(requestBytes, 0, requestBytes.Length);
20             requestStream.Close();
21             HttpWebResponse res = (HttpWebResponse)req.GetResponse();
22             StreamReader sr = new StreamReader(res.GetResponseStream(), System.Text.Encoding.GetEncoding("utf-8"));
23             string backstr = sr.ReadToEnd();//能夠讀取到從頁面返回的結果，以數據流的形式。
24             sr.Close();
25             res.Close();
26 
27             return backstr;
28         }

View Code

而後在分享服務上的耗時操做，下同。

 1  /// <summary>
 2         /// 耗時方法  耗時3s
 3         /// </summary>
 4         /// <returns></returns>
 5         public ActionResult GetMsg1()
 6         {
 7             Thread.Sleep(3000);
 8             return Content("GetMsg1");
 9 
10         }
11 
12         /// <summary>
13         /// 耗時方法  耗時5s
14         /// </summary>
15         /// <returns></returns>
16         public ActionResult GetMsg2()
17         {
18             Thread.Sleep(5000);
19             return Content("GetMsg2");
20 
21         }

View Code

下面是案例1代碼

 1  　　　　　　#region 案例1(傳統同步方式 耗時8s左右)
 2             {
 3                 Stopwatch watch = Stopwatch.StartNew();
 4                 Console.WriteLine("開始執行");
 5 
 6                 string t1 = HttpService.PostData("", "http://localhost:2788/Home/GetMsg1");
 7                 string t2 = HttpService.PostData("", "http://localhost:2788/Home/GetMsg2");
 8 
 9                 Console.WriteLine("我是主業務");
10                 Console.WriteLine($"{t1},{t2}");
11                 watch.Stop();
12                 Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
13             }
14             #endregion

② 開啓新線程分別執行兩個耗時操做

　　須要的時間大約爲：Max(3s,5s) = 5s ,以下面【案例2】

 1   　　　　　　#region 案例2(開啓新線程分別執行兩個耗時操做 耗時5s左右)
 2             {
 3                 Stopwatch watch = Stopwatch.StartNew();
 4                 Console.WriteLine("開始執行");
 5 
 6                 var task1 = Task.Run(() =>
 7                 {
 8                     return HttpService.PostData("", "http://localhost:2788/Home/GetMsg1");
 9                 });
10 
11                 var task2 = Task.Run(() =>
12                 {
13                     return HttpService.PostData("", "http://localhost:2788/Home/GetMsg2");
14                 });
15 
16                 Console.WriteLine("我是主業務");
17                 //主線程進行等待
18                 Task.WaitAll(task1, task2);
19                 Console.WriteLine($"{task1.Result},{task2.Result}");
20                 watch.Stop();
21                 Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
22             }
23             #endregion

　　既然②方式能夠解決同步方法串行耗時間的問題，但這種方式存在一個弊端，一個業務中存在多個線程，且須要對線程進行管理，相對麻煩，從而引出了異步方法。

這裏的異步方法我特指：系統類庫自帶的以async結尾的異步方法。

③ 使用系統類庫自帶的異步方法

　　須要的時間大約爲：Max(3s,5s) = 5s ,以下面【案例3】

 1 　　　　　　#region 案例3(使用系統類庫自帶的異步方法 耗時5s左右)
 2             {
 3                 Stopwatch watch = Stopwatch.StartNew();
 4                 HttpClient http = new HttpClient();
 5                 var httpContent = new StringContent("", Encoding.UTF8, "application/json");
 6                 Console.WriteLine("開始執行");
 7                 //執行業務
 8                 var r1 = http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
 9                 var r2 = http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
10                 Console.WriteLine("我是主業務");
11 
12                 //經過異步方法的結果.Result能夠是異步方法執行完的結果
13                 Console.WriteLine(r1.Result.Content.ReadAsStringAsync().Result);
14                 Console.WriteLine(r2.Result.Content.ReadAsStringAsync().Result);
15 
16                 watch.Stop();
17                 Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
18             }
19             #endregion

PS：經過 .Result 來獲取異步方法執行完後的結果。

二. 利用async和await封裝異步方法

1. 首先要聲明幾點：

　　① async和await關鍵字是C# 5.0時代引入的，它是一種異步編程模型

　　② 它們自己並不建立新線程，但我能夠在自行封裝的async中利用Task.Run開啓新線程

　　③ 利用async關鍵字封裝的方法中若是寫所有都是一些串行業務, 且不用await關鍵字，那麼即便使用async封裝，也並無什麼卵用，並起不了異步方法的做用。

　　須要的時間大約爲：3s + 5s =8s, 以下面 【案例4】，而且封裝的方法編譯器會提示：「缺乏關鍵字await，將以同步的方式調用，請使用await運算符等待非阻止API或Task.Run的形式」（PS：非阻止API指系統類庫自帶的以Async結尾的異步方法）

 1        //利用async封裝同步業務的方法
 2         private static async Task<string> NewMethod5Async()
 3         {
 4             Thread.Sleep(3000);
 5             //其它同步業務
 6             return "Msg1";
 7         }
 8         private static async Task<string> NewMethod6Async()
 9         {
10             Thread.Sleep(5000);
11             //其它同步業務
12             return "Msg2";
13         }

View Code

 1            #region 案例4(async關鍵字封裝的方法中若是寫所有都是一些串行業務 耗時8s左右)
 2             {
 3                 Stopwatch watch = Stopwatch.StartNew();
 4 
 5                 Console.WriteLine("開始執行");
 6 
 7                 Task<string> t1 = NewMethod5Async();
 8                 Task<string> t2 = NewMethod6Async();
 9 
10                 Console.WriteLine("我是主業務");
11                 Console.WriteLine($"{t1.Result},{t2.Result}");
12                 watch.Stop();
13                 Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
14             }
15             #endregion

　　觀點結論1：從上面③中能夠得出一個結論，async中必需要有await運算符才能起到異步方法的做用，且await 運算符只能加在系統類庫默認提供的異步方法或者新線程（如：Task.Run）前面。

　　如：下面【案例5】 和 【案例6】須要的時間大約爲：Max(3s,5s) = 5s

 1 // 將系統類庫提供的異步方法利用async封裝起來
 2         private static async Task<String> NewMethod1Async()
 3         {
 4             HttpClient http = new HttpClient();
 5             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
 6             //執行業務
 7             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
 8             return r1.Content.ReadAsStringAsync().Result;
 9         }
10         private static async Task<String> NewMethod2Async()
11         {
12             HttpClient http = new HttpClient();
13             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
14             //執行業務
15             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
16             return r1.Content.ReadAsStringAsync().Result;
17         }
18 
19         //將await關鍵字加在新線程的前面
20         private static async Task<string> NewMethod3Async()
21         {
22             var msg = await Task.Run(() =>
23             {
24                 return HttpService.PostData("", "http://localhost:2788/Home/GetMsg1");
25             });
26             return msg;
27         }
28         private static async Task<string> NewMethod4Async()
29         {
30             var msg = await Task.Run(() =>
31             {
32                 return HttpService.PostData("", "http://localhost:2788/Home/GetMsg2");
33             });
34             return msg;
35         }

View Code

 1  　　　　　　#region 案例5(將系統類庫提供的異步方法利用async封裝起來 耗時5s左右)
 2             //而且先輸出「我是主業務」，證實t1和t2是並行執行的，且不阻礙主業務
 3             {
 4                 Stopwatch watch = Stopwatch.StartNew();
 5 
 6                 Console.WriteLine("開始執行");
 7                 Task<string> t1 = NewMethod1Async();
 8                 Task<string> t2 = NewMethod2Async();
 9 
10                 Console.WriteLine("我是主業務");
11                 Console.WriteLine($"{t1.Result},{t2.Result}");
12                 watch.Stop();
13                 Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
14             }
15             #endregion

 1    　　　　#region 案例6(將新線程利用async封裝起來 耗時5s左右)
 2             //而且先輸出「我是主業務」，證實t1和t2是並行執行的，且不阻礙主業務
 3             {
 4                 Stopwatch watch = Stopwatch.StartNew();
 5 
 6                 Console.WriteLine("開始執行");
 7                 Task<string> t1 = NewMethod3Async();
 8                 Task<string> t2 = NewMethod4Async();
 9 
10                 Console.WriteLine("我是主業務");
11                 Console.WriteLine($"{t1.Result},{t2.Result}");
12                 watch.Stop();
13                 Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
14             }
15             #endregion

2. 幾個規則和約定

　　① async封裝的方法中，能夠有多個await，這裏的await表明等待該行代碼執行完畢。

　　② 咱們一般本身封裝的方法也要以Async結尾，方便識別

　　③ 異步返回類型主要有三種：Task<T> 、Task、Void

3. 測試得出其餘幾個結論

① 若是async封裝的異步方法裏既有同步業務又有異步業務(開啓新線程或者系統類庫提供異步方法)，那麼同步方法那部分的時間在調用的時候是會阻塞主線程的，即主線程要等待這部分同步業務執行完才能往下執行。

　　如【案例7】 耗時：同步操做之和 2s+2s + Max(3s,5s)=9s;

 1   //同步耗時操做和異步方法同時封裝
 2         private static async Task<String> NewMethod7Async()
 3         {
 4             //調用異步方法以前還有一個耗時操做
 5             Thread.Sleep(2000);
 6 
 7             //下面的操做耗時3s
 8             HttpClient http = new HttpClient();
 9             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
10             //執行業務
11             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
12             return r1.Content.ReadAsStringAsync().Result;
13         }
14         private static async Task<String> NewMethod8Async()
15         {
16             //調用異步方法以前還有一個耗時操做
17             Thread.Sleep(2000);
18 
19             //下面的操做耗時5s
20             HttpClient http = new HttpClient();
21             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
22             //執行業務
23             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
24             return r1.Content.ReadAsStringAsync().Result;
25         }

View Code

 1  　　　　 #region 案例7(既有普通的耗時操做，也有系統自己的異步方法,耗時9s左右)
 2             //且大約4s後才能輸出 「我是主業務」，證實同步操做Thread.Sleep(2000);  阻塞主線程
 3             {
 4                 Stopwatch watch = Stopwatch.StartNew();
 5 
 6                 Console.WriteLine("開始執行");
 7                 Task<string> t1 = NewMethod7Async();
 8                 Task<string> t2 = NewMethod8Async();
 9 
10                 Console.WriteLine("我是主業務");
11                 Console.WriteLine($"{t1.Result},{t2.Result}");
12                 watch.Stop();
13                 Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
14             }
15             #endregion

　　證實：async封裝的異步方法裏的同步業務的時間會阻塞主線程，再次證實 await只能加在非阻止api和開啓新線程的前面

② 若是封裝的異步方法中存在等待的問題，並且不能阻塞主線程(不能用Thread.Sleep) , 這個時候能夠用Task.Delay，並在前面加await關鍵字

　　如【案例8】 耗時：Max（2+3 , 5+2）=7s

 1    //利用Task.Delay(2000);等待
 2         private static async Task<String> NewMethod11Async()
 3         {
 4             //調用異步方法以前須要等待2s
 5             await Task.Delay(2000);
 6 
 7             //下面的操做耗時3s
 8             HttpClient http = new HttpClient();
 9             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
10             //執行業務
11             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
12             return r1.Content.ReadAsStringAsync().Result;
13         }
14 
15         private static async Task<String> NewMethod12Async()
16         {
17             //調用異步方法以前須要等待2s
18             await Task.Delay(2000);
19 
20             //下面的操做耗時5s
21             HttpClient http = new HttpClient();
22             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
23             //執行業務
24             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
25             return r1.Content.ReadAsStringAsync().Result;
26         }

View Code

 1  　　　　　　 #region 案例8(利用Task.Delay執行異步方法的等待操做)
 2             //結果是7s，且立刻輸出「我是主業務」，說明Task.Delay(),不阻塞主線程。
 3             {
 4                 Stopwatch watch = Stopwatch.StartNew();
 5                 Console.WriteLine("開始執行");
 6                 Task<string> t1 = NewMethod11Async();
 7                 Task<string> t2 = NewMethod12Async();
 8 
 9                 Console.WriteLine("我是主業務");
10                 Console.WriteLine($"{t1.Result},{t2.Result}");
11                 watch.Stop();
12                 Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
13             }
14             #endregion

三. 異步方法返回類型

1. Task<T>, 處理含有返回值的異步方法，經過 .Result 等待異步方法執行完，且獲取到返回值。

2. Task：調用方法不須要從異步方法中取返回值，可是但願檢查異步方法的狀態，那麼能夠選擇能夠返回 Task 類型的對象。不過，就算異步方法中包含 return 語句，也不會返回任何東西。

　　如【案例9】

 1   
 2         //返回值爲Task的方法
 3         private static async Task NewMethod9Async()
 4         {
 5 
 6             //下面的操做耗時3s
 7             HttpClient http = new HttpClient();
 8             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
 9             //執行業務
10             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
11             Console.WriteLine("NewMethod9Async執行完成");
12         }

View Code

 1  　　　　　　#region 案例9(返回值爲Task的異步方法)
 2             //結果是5s，說明異步方法和主線程的同步方法 在並行執行
 3             {
 4                 Stopwatch watch = Stopwatch.StartNew();
 5 
 6                 Console.WriteLine("開始執行");
 7                 Task t = NewMethod9Async();
 8 
 9                 Console.WriteLine($"{nameof(t.Status)}: {t.Status}");   //任務狀態
10                 Console.WriteLine($"{nameof(t.IsCompleted)}: {t.IsCompleted}");     //任務完成狀態標識
11                 Console.WriteLine($"{nameof(t.IsFaulted)}: {t.IsFaulted}");     //任務是否有未處理的異常標識
12 
13                 //執行其餘耗時操做，與此同時NewMethod9Async也在工做
14                 Thread.Sleep(5000);
15      
16                 Console.WriteLine("我是主業務");
17 
18                 t.Wait();
19 
20                 Console.WriteLine($"{nameof(t.Status)}: {t.Status}");   //任務狀態
21                 Console.WriteLine($"{nameof(t.IsCompleted)}: {t.IsCompleted}");     //任務完成狀態標識
22                 Console.WriteLine($"{nameof(t.IsFaulted)}: {t.IsFaulted}");     //任務是否有未處理的異常標識
23 
24                 Console.WriteLine($"全部業務執行完成了");
25                 watch.Stop();
26                 Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
27             }
28             #endregion

　　PS：對於Task返回值的異步方法，能夠調用Wait(),等待該異步方法執行完，他和await不一樣，await必須出如今async關鍵字封裝的方法中。

3. void：調用異步執行方法，不須要作任何交互

　　如【案例10】

 1     //返回值是Void的方法
 2         private static async void NewMethod10Async()
 3         {
 4             //下面的操做耗時5s
 5             HttpClient http = new HttpClient();
 6             var httpContent = new StringContent("", Encoding.UTF8, "application/json");
 7             //執行業務，假設這裏主須要請求，不須要作任何交互
 8             var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
 9             Console.WriteLine("NewMethod10Async執行完成");
10         }

View Code

 1   　　　　　　#region 案例10(返回值爲Void的異步方法)
 2             //結果是5s，說明異步方法和主線程的同步方法 在並行執行
 3             {
 4                 Stopwatch watch = Stopwatch.StartNew();
 5 
 6                 Console.WriteLine("開始執行");
 7                 NewMethod10Async();
 8 
 9                 //執行其餘耗時操做，與此同時NewMethod9Async也在工做
10                 Thread.Sleep(5000);
11 
12                 Console.WriteLine("我是主業務");
13 
14 
15                 Console.WriteLine($"全部業務執行完成了");
16                 watch.Stop();
17                 Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
18             }
19             #endregion