異步方法—Async、Await

一：前言

1.所有帶有Async關鍵字的異步方法返回類型：

　　　　① Task<T>：如果調用方法想通過調用異步方法獲取一個T類型的返回值，那么簽名必須為Task<TResult>；

　　　　② Task:如果調用方法不想通過異步方法獲取一個值，僅僅想追蹤異步方法的執行狀態，那么我們可以設置異步方法簽名的返回值為Task;

　　　　③ void:如果調用方法僅僅只是調用一下異步方法，不和異步方法做其他交互，我們可以設置異步方法簽名的返回值為void，這種形式也叫做“調用;

即：異步方法的返回值類型必須為Task或Task<T>；

2.異步方法的“傳染性“：一個方法中如果有await調用，則這個方法也必須修飾為async。

3.在async方法中遇到await關鍵字后，當前線程立即返回(到調用方)，繼續之前的處理邏輯；await關鍵字之后的代碼邏輯，將交由新的線程處理；當新的線程處理完成后，可以從新的線程返回處理結果到調用(處)線程當中，結束等待。

4.在一個async方法中，會根據await關鍵字進行分割，拆分到不同的線程處理同一個方法的不同部分！如下例：

 static void Main(string[] args)
        {
            Console.WriteLine("{0}->Main.異步方法執行前", Thread.CurrentThread.ManagedThreadId.ToString());//輸出異步處理之前的線程ID
            DoAsync(1000).Wait();//執行異步處理，並等待該異步方法執行完成后才繼續
            Console.WriteLine("{0}->Main.異步方法執行后", Thread.CurrentThread.ManagedThreadId.ToString());//輸出異步處理之后的線程ID

            Console.Read();
        }


        /// <summary>
        /// 執行異步處理
        /// </summary>
        /// <param name="times">模擬處理時長</param>
        /// <returns></returns>
        public static async Task DoAsync(int times)
        {
            Console.WriteLine("{0}->DoAsync.await之前", Thread.CurrentThread.ManagedThreadId.ToString());//輸出調用線程ID
            await Task.Run(() => Thread.Sleep(times));///執行一個異步任務，並等待返回結果才繼續；需要注意的是，調用線程執行到這一行的時候其實就已經返回了
            Console.WriteLine("{0}->DoAsync.await之后", Thread.CurrentThread.ManagedThreadId.ToString());//異步操作執行完了，但這里已經是新的線程了
        }

運行結果：

 

 

請注意：在同步方法Main中執行的時候都是同一個線程；在異步方法DoAsync執行的時候，在await之前是調用線程，在await之后則是另一個線程。

 

5.把一個方法代碼的不同部分拆分到多個線程處理，這是異步方法和同步方法的最大不同！

 

總而言之：

在異步(async)方法執行中，會根據await關鍵字，拆分一個方法為多個部分，分別由不同的線程執行。

在異步(async)方法執行中，遇到await關鍵字，調用線程會立即返回(線程池)繼續后續的處理邏輯；而后，調用方可以使用Task.Wait()或Task<T>.Result進行阻塞，等待異步方法執行完畢再繼續。

在異步(async)方法執行后，若不使用Task.Wait()進行等待，或不使用Task<T>.Result獲取返回結果，則該方法將僅以異步方式執行。

 

二：詳解Async和await關鍵字

1.Async和await細節

 

async和await可以創建和使用異步方法，這個特性的由三個部分組成：

 

①調用方法(calling method)：該方法調用異步方法，然后在異步方法（可能使用同一個線程也可能不在一個線程）執行其任務的時候繼續執行

 

②異步方法（async）: 該方法異步執行其工作，然后立即方法到調用方法

 

③await表達式：用於異步方法內部，指明需要異步執行的惹怒我。一個異步方法可以包含任意多個await表達式，如果一個都不包含編譯器會發出警告

//1.調用方法
static void Main(string[] args)
{
    Task<int> t = DoSumAsync(1, 2);
    Console.WriteLine("結果:{0}", t.Result);
    Console.ReadKey();
}
 
//2.異步方法
public static async Task<int> DoSumAsync(int a, int b)
{
    //3.await 表達式
    int sum = await Task.Run(() => { return a + b; });
    return sum;
}

2.什么是異步？

異步方法在完成其工作之前返回到調用方法，並在調用方法繼續執行的時候完成其工作。語法上有如下特征：

① 方法使用async作為修飾符

② 方法內部包含一個或者多個await表達式，表示可以異步完成的任務

③ 必須具備以下三種返回類型 void 、Task 、Task<T> ,其中后兩種的返回對象標識講座未來完成的工作，調用方法和異步方法可以繼續執行。

④異步方法的參數可以任意類型，但是不能為out和ref參數

⑤約定俗成，一般異步方法都是以 Async作為后綴的。

⑥ 除了方法之外，Lambda表達式和匿名函數也可以作為異步對象。

private async Task<int> CountCharactersAsync(int id, string uriString)
{
    WebClient wc = new WebClient();
    Console.WriteLine("Call {0} start: {1:N0}ms ", id, sw.Elapsed.TotalMilliseconds);
    string result = await wc.DownloadStringTaskAsync(new Uri(uriString));
    Trace.TraceInformation("Taceing Async Call {0} @time:{1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
    Console.WriteLine("Call {0} completed: {1:N0}ms", id, sw.Elapsed.TotalMilliseconds);
    return result.Length;
}

詳細說明：

①async關鍵字是一個上下文關鍵字，也就是說除了做為方法（lambda和匿名函數）的修飾符之外，還可以做標識符。

②返回類型

Task類型：如果調用方法不需要從異步方法中返回某個值，但需要檢查異步方法的狀態，可以返回一個Task，此時就算異步方法中出現了return語句，也不會返回任何東西。

Task<T>類型，除了上面Task的功能，還可以通過 Return屬性來獲取返回的T類型的值。

void類型：如果僅僅是執行異步方法，而不需要與它做任何進一步的交互（“調用並忘記”），此時可以用void，和Task一樣，就算有return語句，也得不到任何東西。

3.異步方法的控制流

首先要明確“異步方法”的三個部分，如下圖所示：

①首先是第一個await之前的部分，這部分應該是少量且無需長時間等待的代碼。

②await表達式，表示需要被異步執行的任務，這里有兩個await表達式，第二個await和之前的同步部分和第一個await以及之前的部分是一樣的。

③后續部分：在await表達式之后出現的方法中的其余代碼。

執行過程：

 

 

有幾個注意的地方：

 

① await之前的部分是同步執行的

 

② 當達到awati的時候，會將異步方法的控制返回給調用方法。如果方法返回的類型是Task或者Task<T>，將創建一個Task對象，表示需異步完成的任務和后續，然后將該Task返回到調用方法。 這里的返回值並不是await表達式的返回值，而是異步方法中聲明的返回值類型。

 

③ 異步方法內部需要完成以下工作：

 

　　- 異步執行await表達是的空閑任務

 

       - 當await表達式執行完成之后，執行后續部分。后續本身也可能是await表達式，處理過程和上一個一致。

 

　　- 后續部分如果遇到 return 或者 方法達到末尾，將做如下的事情：

 

　　　　l  如果返回的類型是void,控制流就退出了

 

　　　　l  如果返回的類型是Task，后續部分設置Task對象的屬性並退出。

 

　　　　l  如果返回的類型是Task<T>，不僅要設置Task對象屬性，還要設置Task對象的Return屬性。

 

  　　這個點要注意下：並不是遇到return或者達到方法末尾，就能獲取到返回值，它只是退出了。

 

④ 調用方法繼續執行，會從異步方法獲取Task對象。當需要其實際值的時候，就引用Task對象中的Result屬性。屆時，如果異步方法設置了該屬性，調用方法獲取其值並繼續。否則就等待該屬性被設置，然后再繼續執行。

4.await表達式

await表達式指定了一個異步執行的任務。語法由 await關鍵字 + 一個空閑對象(稱為任務)組成。這個任務可能是一個Task對象，也可以不是，默認情況下由該線程異步執行。

一個空閑對象 指的是一個awaitable類型的實例，awaitable類型是指包含了GetAwaiter方法的類型，方法沒有參數，返回一個稱為awaiter類型的對象。

 

 一個awaiter對象包含了如下成員：

 

一般情況下我們不需要自己構建一個awaiter對象，使用.net 自己的Task就可以了。最簡單的方法就是使用Task.Run()來返回一個Task對象。關於Task.Run()有一個非常重要的點，他將在不同的線程上運行你的方法。

5.異常處理和await表達式

static void Main(string[] args)
{
 
    Task t = BadAsync();
    t.Wait();
    Console.WriteLine("Task Status:       {0}", t.Status );
    Console.WriteLine("Task IsFaulted:    {0}", t.IsFaulted );
    Console.WriteLine("Please enter a key to exit!");
    Console.ReadKey();
 
}
 
static async Task BadAsync()
{
    try
    {
        await Task.Run(() => { throw new Exception(); });
    }
    catch
    {
        Console.WriteLine("Exception in BadAsync");
    }
}

運行結果：

 

 

 從結果可以看到，雖然在異步方法內部進行了try..catch，並且也catch到了異常，但是對於調用函數，返回的Task狀態依然為 RanToCompletion 。

為什么這個亞子？，原因如下：

① Task沒有被取消掉

② 沒有未處理的異常。類似的IsFaulted是false。

 6.在調用方法中同步的等待任務（WaitAll、WaitAny）

對於單個Task，可以通過task對象的wait方法等待：

Task<int> t = CountCharactersAsync("http://www.163.com");
t.Wait();

對於多個Task，可以使用WaitAll()或者WaitAny()方法，進行同步：

Task<int> t1 = CountCharactersAsync(1, "http://www.163.com");
Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com");
Task<int>[] tasks = new Task<int>[] { t1, t2 };
Task.WaitAll(tasks);

WaitAny是只要一個完成就可以繼續操作：

Task<int> t1 = CountCharactersAsync(1, "http://www.163.com");
Task<int> t2 = CountCharactersAsync(2, "http://www.microsoft.com");
Task<int>[] tasks = new Task<int>[] { t1, t2 };
Task.WaitAny(tasks);

7.在異步方法中異步的等待任務 （WhenAll、.WhenAny）

上面說明了如何在“調用方法”中，同步等待Task的完成。 但是有時候，我們在一個異步方法中也會存在多個任務，想要讓它們通過await表達式等待。我們可以通過Task.WhenAll() 和 Task.WhenAny() 方法實現。 這兩個方法稱為組合子（combinator）。

private async Task<int> CountCharactersAsync(string site1, string site2)
{
    WebClient wc1 = new WebClient();
    WebClient wc2 = new WebClient();
 
    Task<string> t1 = wc1.DownloadStringTaskAsync(new Uri(site1));
    Task<string> t2 = wc2.DownloadStringTaskAsync(new Uri(site2));
 
    List<Task<string>> tasks = new List<Task<string>>();
    tasks.Add(t1);
    tasks.Add(t2);
 
    //組合子
    await Task.WhenAll(tasks);
    //await Task.WhenAny(tasks);
 
    Console.WriteLine("   CCA:  T1 {0} Finished", t1.IsCompleted ? "" : "Not");
    Console.WriteLine("   CCA:  T2 {0} Finished", t2.IsCompleted ? "" : "Not");
 
    return t1.IsCompleted? t1.Result.Length: t2.Result.Length;
}

8.使用Task.Delay暫停線程處理

一般我們都使用Thread.Sleep(xxxx) 進行線程的延時，但是 Thread.Sleep會阻塞線程。而Task.Delay則不會阻塞線程，線程可以繼續處理其他的工作。

class Simple
{
    Stopwatch sw = new Stopwatch();
    public void DoRun()
    {
        Console.WriteLine("Caller: Before call");
        ShowDelayAsync();
        Console.WriteLine("Caller: After call");
 
    }
    private async void ShowDelayAsync()
    {
        sw.Start();
        Console.WriteLine("   Before Delay:  {0} ", sw.Elapsed.Milliseconds );
        await Task.Delay(1000);
        Console.WriteLine("   After  Delay:  {0} ", sw.Elapsed.Milliseconds);
    }
}