多線程編程學習筆記——async和await（二）

本示例學習如何閱讀有多個await方法方法時，程式的實際流程是怎麼樣的，理解await的非同步調用。 ...

三、對連續的非同步任務使用await操作符

本示例學習如何閱讀有多個await方法方法時，程式的實際流程是怎麼樣的，理解await的非同步調用。

1。示例代碼如下。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading; 

namespace ThreadAsyncDemo
{

    class Program
    {
        static void Main(string[] args)
        {

Console.WriteLine(string.Format("----- 對連續的非同步任務使用await操作符----"));

            Task t = AsyncWithTPL();
            t.Wait();
            t = AsyncWithAwait();
            t.Wait();
            Console.Read();          
        }

 

        static Task AsyncWithTPL()
        {
            var containerTask = new Task(() =>
            {
                Task<string> task1 = GetInfoAsync("TPL Task 1");

                task1.ContinueWith(task =>
                {
                    Console.WriteLine(task1.Result);

                    Task<string> task2 = GetInfoAsync("TPL Task 2");
                    task2.ContinueWith(innerTask =>
              Console.WriteLine(innerTask.Result), TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent);

                    task2.ContinueWith(innerTask =>
Console.WriteLine(innerTask.Exception.InnerException), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent); 

                }, TaskContinuationOptions.NotOnFaulted | TaskContinuationOptions.AttachedToParent);
                task1.ContinueWith(task =>
              Console.WriteLine(task1.Exception.InnerException), TaskContinuationOptions.OnlyOnFaulted | TaskContinuationOptions.AttachedToParent);
            }
            );
            containerTask.Start();
            return containerTask;
        }
        async static Task AsyncWithAwait()
        {
            try
            {
                string result = await GetInfoAsync("Async Task 1");
                Console.WriteLine(result);
                 result = await GetInfoAsync("Async Task 2");
                Console.WriteLine(result);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }
        }
 
        async static Task<string> GetInfoAsync(string name)
        {
            Console.WriteLine(string.Format("任務 {0} 開始。。。",name));
            await Task.Delay(TimeSpan.FromSeconds(2));
            if(name== "TPL Task 2")
            throw new Exception(string.Format("{0} 拋出異常信息！", name));
            return string.Format(" Task {0} 正在運行線上程 ID={1}上。這個工作線程是否是線程池中的線程：{2}", name,
 Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
        }
    }
}

2.程式運行結果，如下圖。

首先，程式運行時會執行兩個非同步操作。

AsyncWithAwait方法，它看起來跟平常的代碼一樣，唯一不同之處就是使用了兩個await聲明。最重要的一點是代碼的執行順序依然是順序執行的，調用AsyncWithAwait任務的代碼只有等之前的的任務完成後才會開始執行。當閱讀代碼時，程式流很清晰，可以看到什麼先執行，什麼後執行，但是程式如何非同步執行呢？首先，它不是一直是非同步執行的，只有當使用await，且一個任務已經完成，我們會非同步地得到這個任務的結果。否則，當在代碼中看到await聲明時，通過的行為是代碼執行到await代碼行時將立即返回，並且剩下的代碼將會在一個後續操作任務中運行。因此等待操作結果時並沒有阻塞程式執行，這是一個非同步調用。當AsyncWithAwait方法中的代碼執行時，除了在main方法中調用 t.wait外，我們可以執行任務其他任務。但是主線程必須等待直到所有的非同步操作完成，否則主線程完成後所有運行非同步操作的後臺線程會停止運行。
AsyncWithTPL方法模仿了AsyncWithAwait的程式流。我們需要一個容器任務來處理所有相互依賴的任務。然後啟動主任務，給其加了一組後續操作。當這個任務完成後，會列印其結果。然後又啟動了一個任務，在這個任務完成後會依次運行更多的後續操作。為了測試對異常的處理，當運行第二個任務時故意拋出了一個異常。並列印出異常信息。這組後續操作創建了與第一個方法中一樣的程式流。

二、對並行執行的非同步任務使用await操作符

本示例學習如何使用await來並行地運行非同步任務，而不採用常規使用順序執行方式。

1.示例代碼如下。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading; 

namespace ThreadAsyncDemo
{

    class Program
    {

        static void Main(string[] args)
        {
            Console.WriteLine(string.Format("-----    對並行執行的非同步任務使用await操作符----"));
            Task t = AsyncProcess();
            t.Wait();      
            Console.Read();           

        }

        async static Task AsyncProcess()
        {

            Task<string> task1 = GetInfoAsync("Task 1",3);        

                Task<string> task2 = GetInfoAsync("Task 2",5);
            string[] results = await Task.WhenAll(task1, task2);
            foreach (var item in results)
            {
                Console.WriteLine(item);
            }
        }

        async static Task<string> GetInfoAsync(string name,int second)
        {
            Console.WriteLine(string.Format("任務 {0} 開始。。。",name));

            await Task.Delay(TimeSpan.FromSeconds(second));
            //await Task.Run(() => Thread.Sleep(TimeSpan.FromSeconds(second));
            return string.Format(" Task {0} 正在運行線上程 ID={1}上。這個工作線程是否是線程池中的線程：{2}", name,
 Thread.CurrentThread.ManagedThreadId, Thread.CurrentThread.IsThreadPoolThread);
        }
    }
}

2.程式運行結果，如下圖。

在AsyncProcess方法中定義了兩個非同步任務task1,task2，分別運行3秒和5秒。然後使用Task.WhenAll輔助方式得到了兩個任務的運行結果，而且只有在所有底層任務完成之後，才會運行。之後我們等待這個組合任務的結果。5秒後，我們獲取所有結果，說明瞭這些任務是同時運行的。

我們仔細觀察會發現，這兩個任務假托是被線程池中的同一個工作線程執行的。當我們並行運行任務時怎麼可能發生這樣的情況呢？我們註釋掉GetIntroAsync方法中的await Task.Delay代碼行，並解除對await task.run代碼行的註釋，然後再次運行程式。

我們會看到這種情況下，兩個任務會被不同的工作線程執行。不同之處是task.delay在幕後使用了一個計時器，過程如下：從線程池中獲取工作線程，它將等待task.delay方法返回結果。然後task.delay方法啟動計時器並指定一段代碼，這段代碼會在計時器時間到了task.delay方法中指定的秒數後被調用，之後，立即將工作線程返回到線程池中。當計時器事件運行時，又從線程池中任意獲取一個可用的工作線程（可能跟上次運行的是同一個工作線程），並運行計時器指定的代碼。

當使用task.run方法時，從線程池中獲取了一個工作線程並將其阻塞幾秒，然後獲取了第二個工作線程也將其阻塞。在這種情況下，我們消費了兩個工作線程，但是什麼事情也沒做。如下圖。比較兩者的不同之處，在於兩個task運行在不同的線程上。