async 和await 的用法

https://www.cnblogs.com/yaopengfei/p/9249390.html

 

 

① 傳統的同步方式：

public class HttpService
    {
        /// <summary>
        /// 後臺跨域請求發送代碼
        /// </summary> 
        /// <param name="url">eg:http://ac.guojin.org/jeesite/regist/saveAppAgentAccount </param>
        ///<param name="postData"></param>
        ///  參數格式（手拼Json） string postData = "{\"name\":\"" + vip.comName + "\",\"shortName\":\"" + vip.shortName + + "\"}";             
        /// <returns></returns>
        public static string PostData(string postData, string url)
        {
            HttpWebRequest req = (HttpWebRequest)WebRequest.Create(url);//後臺請求頁面
            Encoding encoding = Encoding.GetEncoding("utf-8");//注意頁面的編碼，否則會出現亂碼
            byte[] requestBytes = encoding.GetBytes(postData);
            req.Method = "POST";
            req.ContentType = "application/json";
            req.ContentLength = requestBytes.Length;
            Stream requestStream = req.GetRequestStream();
            requestStream.Write(requestBytes, 0, requestBytes.Length);
            requestStream.Close();
            HttpWebResponse res = (HttpWebResponse)req.GetResponse();
            StreamReader sr = new StreamReader(res.GetResponseStream(), System.Text.Encoding.GetEncoding("utf-8"));
            string backstr = sr.ReadToEnd();//可以讀取到從頁面返回的結果，以數據流的形式。
            sr.Close();
            res.Close();

            return backstr;
        }

/// <summary>
        /// 耗時方法  耗時3s
        /// </summary>
        /// <returns></returns>
        public ActionResult GetMsg1()
        {
            Thread.Sleep(3000);
            return Content("GetMsg1");

        }

        /// <summary>
        /// 耗時方法  耗時5s
        /// </summary>
        /// <returns></returns>
        public ActionResult GetMsg2()
        {
            Thread.Sleep(5000);
            return Content("GetMsg2");

        }

#region 案例1(傳統同步方式 耗時8s左右)
            {
                Stopwatch watch = Stopwatch.StartNew();
                Console.WriteLine("開始執行");

                string t1 = HttpService.PostData("", "http://localhost:2788/Home/GetMsg1");
                string t2 = HttpService.PostData("", "http://localhost:2788/Home/GetMsg2");

                Console.WriteLine("我是主業務");
                Console.WriteLine($"{t1},{t2}");
                watch.Stop();
                Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
            }
            #endregion

這樣的耗時就會是3+5=8s

 

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

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

#region 案例2(開啓新線程分別執行兩個耗時操作 耗時5s左右)
            {
                Stopwatch watch = Stopwatch.StartNew();
                Console.WriteLine("開始執行");

                var task1 = Task.Run(() =>
                {
                    return HttpService.PostData("", "http://localhost:2788/Home/GetMsg1");
                });

                var task2 = Task.Run(() =>
                {
                    return HttpService.PostData("", "http://localhost:2788/Home/GetMsg2");
                });

                Console.WriteLine("我是主業務");
                //主線程進行等待
                Task.WaitAll(task1, task2);
                Console.WriteLine($"{task1.Result},{task2.Result}");
                watch.Stop();
                Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
            }
            #endregion

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

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

#region 案例3(使用系統類庫自帶的異步方法 耗時5s左右)
            {
                Stopwatch watch = Stopwatch.StartNew();
                HttpClient http = new HttpClient();
                var httpContent = new StringContent("", Encoding.UTF8, "application/json");
                Console.WriteLine("開始執行");
                //執行業務
                var r1 = http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
                var r2 = http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
                Console.WriteLine("我是主業務");

                //通過異步方法的結果.Result可以是異步方法執行完的結果
                Console.WriteLine(r1.Result.Content.ReadAsStringAsync().Result);
                Console.WriteLine(r2.Result.Content.ReadAsStringAsync().Result);

                watch.Stop();
                Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
            }
            #endregion

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

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

②它們本身並不創建新線程，但是可以在自行封裝的async中利用ask.Run開啓新線程

③利用async關鍵字封裝的方法中如果全部都是一些串行業務，且不用await關鍵字，那麼即使使用async封裝，也並沒什麼用，起不到異步方法的作用

//利用async封裝同步業務的方法
        private static async Task<string> NewMethod5Async()
        {
            Thread.Sleep(3000);
            //其它同步業務
            return "Msg1";
        }
        private static async Task<string> NewMethod6Async()
        {
            Thread.Sleep(5000);
            //其它同步業務
            return "Msg2";
        }

#region 案例4(async關鍵字封裝的方法中如果寫全部都是一些串行業務 耗時8s左右)
            {
                Stopwatch watch = Stopwatch.StartNew();

                Console.WriteLine("開始執行");

                Task<string> t1 = NewMethod5Async();
                Task<string> t2 = NewMethod6Async();

                Console.WriteLine("我是主業務");
                Console.WriteLine($"{t1.Result},{t2.Result}");
                watch.Stop();
                Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
            }
            #endregion

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

// 將系統類庫提供的異步方法利用async封裝起來
        private static async Task<String> NewMethod1Async()
        {
            HttpClient http = new HttpClient();
            var httpContent = new StringContent("", Encoding.UTF8, "application/json");
            //執行業務
            var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
            return r1.Content.ReadAsStringAsync().Result;
        }
        private static async Task<String> NewMethod2Async()
        {
            HttpClient http = new HttpClient();
            var httpContent = new StringContent("", Encoding.UTF8, "application/json");
            //執行業務
            var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
            return r1.Content.ReadAsStringAsync().Result;
        }

        //將await關鍵字加在新線程的前面
        private static async Task<string> NewMethod3Async()
        {
            var msg = await Task.Run(() =>
            {
                return HttpService.PostData("", "http://localhost:2788/Home/GetMsg1");
            });
            return msg;
        }
        private static async Task<string> NewMethod4Async()
        {
            var msg = await Task.Run(() =>
            {
                return HttpService.PostData("", "http://localhost:2788/Home/GetMsg2");
            });
            return msg;
        }

#region 案例5(將系統類庫提供的異步方法利用async封裝起來 耗時5s左右)
            //並且先輸出“我是主業務”，證明t1和t2是並行執行的，且不阻礙主業務
            {
                Stopwatch watch = Stopwatch.StartNew();

                Console.WriteLine("開始執行");
                Task<string> t1 = NewMethod1Async();
                Task<string> t2 = NewMethod2Async();

                Console.WriteLine("我是主業務");
                Console.WriteLine($"{t1.Result},{t2.Result}");
                watch.Stop();
                Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
            }
            #endregion

2 幾個規則和約定

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

② 我們通常自己封裝的方法也要以Async結尾，方便識別

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

3 測試得出其他幾個結論

① 如果async封裝的異步方法裏既有同步業務又有異步業務，name同步犯法的那部分的時間在調用的時候是會阻塞主線程額的，即主線程要等待這部分同步業務執行完才能往下執行。

//同步耗時操作和異步方法同時封裝
        private static async Task<String> NewMethod7Async()
        {
            //調用異步方法之前還有一個耗時操作
            Thread.Sleep(2000);

            //下面的操作耗時3s
            HttpClient http = new HttpClient();
            var httpContent = new StringContent("", Encoding.UTF8, "application/json");
            //執行業務
            var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
            return r1.Content.ReadAsStringAsync().Result;
        }
        private static async Task<String> NewMethod8Async()
        {
            //調用異步方法之前還有一個耗時操作
            Thread.Sleep(2000);

            //下面的操作耗時5s
            HttpClient http = new HttpClient();
            var httpContent = new StringContent("", Encoding.UTF8, "application/json");
            //執行業務
            var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
            return r1.Content.ReadAsStringAsync().Result;
        }

#region 案例7(既有普通的耗時操作，也有系統本身的異步方法,耗時9s左右)
            //且大約4s後才能輸出 “我是主業務”，證明同步操作Thread.Sleep(2000);  阻塞主線程
            {
                Stopwatch watch = Stopwatch.StartNew();

                Console.WriteLine("開始執行");
                Task<string> t1 = NewMethod7Async();
                Task<string> t2 = NewMethod8Async();

                Console.WriteLine("我是主業務");
                Console.WriteLine($"{t1.Result},{t2.Result}");
                watch.Stop();
                Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
            }
            #endregion

 

 ② 如果封裝的異步方法中存在等待的問題，而且不能阻塞主線程(不能用Thread.Sleep) , 這個時候可以用Task.Delay，並在前面加await關鍵字 耗時：Max（2+3 , 5+2）=7s

//利用Task.Delay(2000);等待
        private static async Task<String> NewMethod11Async()
        {
            //調用異步方法之前需要等待2s
            await Task.Delay(2000);

            //下面的操作耗時3s
            HttpClient http = new HttpClient();
            var httpContent = new StringContent("", Encoding.UTF8, "application/json");
            //執行業務
            var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
            return r1.Content.ReadAsStringAsync().Result;
        }

        private static async Task<String> NewMethod12Async()
        {
            //調用異步方法之前需要等待2s
            await Task.Delay(2000);

            //下面的操作耗時5s
            HttpClient http = new HttpClient();
            var httpContent = new StringContent("", Encoding.UTF8, "application/json");
            //執行業務
            var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg2", httpContent);
            return r1.Content.ReadAsStringAsync().Result;
        }

#region 案例8(利用Task.Delay執行異步方法的等待操作)
            //結果是7s，且馬上輸出“我是主業務”，說明Task.Delay(),不阻塞主線程。
            {
                Stopwatch watch = Stopwatch.StartNew();
                Console.WriteLine("開始執行");
                Task<string> t1 = NewMethod11Async();
                Task<string> t2 = NewMethod12Async();

                Console.WriteLine("我是主業務");
                Console.WriteLine($"{t1.Result},{t2.Result}");
                watch.Stop();
                Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
            }
            #endregion

三. 異步方法返回類型

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

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

//返回值爲Task的方法
        private static async Task NewMethod9Async()
        {

            //下面的操作耗時3s
            HttpClient http = new HttpClient();
            var httpContent = new StringContent("", Encoding.UTF8, "application/json");
            //執行業務
            var r1 = await http.PostAsync("http://localhost:2788/Home/GetMsg1", httpContent);
            Console.WriteLine("NewMethod9Async執行完成");
        }

#region 案例9(返回值爲Task的異步方法)
            //結果是5s，說明異步方法和主線程的同步方法 在並行執行
            {
                Stopwatch watch = Stopwatch.StartNew();

                Console.WriteLine("開始執行");
                Task t = NewMethod9Async();

                Console.WriteLine($"{nameof(t.Status)}: {t.Status}");   //任務狀態
                Console.WriteLine($"{nameof(t.IsCompleted)}: {t.IsCompleted}");     //任務完成狀態標識
                Console.WriteLine($"{nameof(t.IsFaulted)}: {t.IsFaulted}");     //任務是否有未處理的異常標識

                //執行其他耗時操作，與此同時NewMethod9Async也在工作
                Thread.Sleep(5000);
     
                Console.WriteLine("我是主業務");

                t.Wait();

                Console.WriteLine($"{nameof(t.Status)}: {t.Status}");   //任務狀態
                Console.WriteLine($"{nameof(t.IsCompleted)}: {t.IsCompleted}");     //任務完成狀態標識
                Console.WriteLine($"{nameof(t.IsFaulted)}: {t.IsFaulted}");     //任務是否有未處理的異常標識

                Console.WriteLine($"所有業務執行完成了");
                watch.Stop();
                Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
            }
            #endregion

 

 PS：對於Task返回值的異步方法，可以調用Wait(),等 待該異步方法執行完，他和await不同，await必須出現在async關鍵字封裝的方法中。

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

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

#region 案例10(返回值爲Void的異步方法)
            //結果是5s，說明異步方法和主線程的同步方法 在並行執行
            {
                Stopwatch watch = Stopwatch.StartNew();

                Console.WriteLine("開始執行");
                NewMethod10Async();

                //執行其他耗時操作，與此同時NewMethod9Async也在工作
                Thread.Sleep(5000);

                Console.WriteLine("我是主業務");


                Console.WriteLine($"所有業務執行完成了");
                watch.Stop();
                Console.WriteLine($"耗時：{watch.ElapsedMilliseconds}");
            }
            #endregion

四. 幾個結論

1.異步方法到底開不開起新線程？

   異步和等待關鍵字不會導致其他線程創建，因爲異步方法本身不會運行線程，異步方法不需要多線程。只有+當方法處於活動狀態，則方法在當前同步上下文中運行並使用在線程的時間。可以使用Task.Run移動CPU工作移到後臺線程，但是，後臺線程不利於等待結果變得可用處理

2 async 和await是一種異步編程模型，它本身並不能開啓新線程，多用於將一些非阻止API或者開啓新線程的操作封裝起來，使其調用的時候像同步方法一樣使用。