[NET] 再探 Task.WaitAll 與 Task.WhenAll 差異

前言
之前自己對於 Task.WaitAll 與 WhenAll 有些一知半解的地方，因此進行研究後並撰寫了 [.NET] Task 等待多個任務 - Task.WaitAll 與 Task.WhenAll 文章，最近在與公司同事 Code Review 再度討論起兩者的使用方式，主管也不吝的與團隊成員分享對於 WaitAll 與 WhenAll 主要的看法與使用上的差異，這篇筆記簡單記錄當時討論的內容與結論，內容若有問題歡迎提出來一起討論。

差異性
首先，在之前文章[.NET] Task 等待多個任務 - Task.WaitAll 與 Task.WhenAll 中思考的出發點是以效率出發，而建議使用 Task.WhenAll 取代 Task.WaitAll 方法，但可能在使用上還是有其他需要考慮的部分，其實效率並不是兩個方法的主要差異，差異性有以下兩點

例外處理 Exception

Task.WaitAll() 處理所有返回 Task 的 Exception
Task.WhenAll() 只能處理第一個返回 Task 的 Exception

我們接下來可以透過簡單的 Code 來說明例外處理的部分，下列代碼定義了兩個 Function 分別是 throw IndexOutOfRangeException 與 NullReferenceException，在 main 的方法使用 WaitAll 並使用 try catch 將觀察例外處理 exception 部分為何

class Program
{
    static async Task Main(string[] args)
    {
        try 
        {
            Task.WaitAll(ThrowIndexOfRangeException(), ThrowNullReferenceException());
        }
        catch (Exception ex) 
        {
            Console.WriteLine(ex);
        }
    }
    
    
    static private Task ThrowIndexOfRangeException()
    {
        return Task.Run(() => { throw new IndexOutOfRangeException();});
    }

    static private Task ThrowNullReferenceException()
    {
        return Task.Run(() => { throw new NullReferenceException(); });
    }
}

開啟 Rider在 catch 下中斷點，可以從 Console 可以看到有抓到兩個 exception，拋出的例外 excption 都有抓到看起來合情合理

接著將 WhenAll 來替換定原有的 WaitAll 方法，再重新跑一次觀察例外處理 exception 是否相同

static async Task Main(string[] args)
{
    var tasks = new [] { ThrowIndexOfRangeException(), ThrowNullReferenceException() };
    try 
    {
        await Task.WhenAll(tasks);
    }
    catch (Exception ex) 
    {
        Console.WriteLine(ex);
    }
}

執行結果如下

可以發現 exception 僅僅抓到第一個拋出的例外也就是 indexOutOfRangeException，並不會抓到拋出來的第二個例外，也就是說 catch 抓到的 exception 僅僅是第一個 exception 其餘的都被河蟹掉了(希望的可能是 catch 到所有的例外)，有開發者在微軟的 Github 反映 Task.WhenAll - Inner exceptions are lost #31494 此問題，內部有針對此問題做深入討論，原先設計方向是使用 WhenAll 時會發生例外時會將錯誤包在 AggregateException 中，後來因為下列原因修改這設計(怕誤解意思直接使用原文)

a) the vast majority of such cases had fairly homogenous exceptions, such that propagating all in an aggregate wasn't that important 
b) propagating the aggregate then broke expectations around catches for the specific exception types, and 
c) for cases where someone did want the aggregate, they could do so explicitly with the two lines like I wrote.

了解設計初衷之後，如果還是希望在 WhenAll 取得所有的例外可以參考討論串中 noseratio 的回答撰寫 Task 擴充方法蒐集 exception ，代碼如下

public static Task WithAggregatedExceptions(this Task @this)
{
    return @this.ContinueWith(ante =>
        ante.IsFaulted && 
            (ante.Exception.InnerExceptions.Count > 1 || 
            ante.Exception.InnerException is AggregateException) ? 
            Task.FromException(ante.Exception.Flatten()) : 
            ante,
        TaskContinuationOptions.ExecuteSynchronously).Unwrap();
}

加入擴充方法後，下一步就是將既有的 WhenAll 代碼加上 WithAggregatedExceptions 擴充方法

static async Task Main(string[] args)
{
    var tasks = new [] { ThrowIndexOfRangeException(), ThrowNullReferenceException() };
    try
    {
        await Task.WhenAll(tasks).WithAggregatedExceptions();
    }
    catch (Exception ex) 
    {
        Console.WriteLine(ex);
    }
}

再重新看一下 Catch 到的錯誤種類，即可發現被河蟹掉的都找的到了 (大師兄回來了

主線程阻塞

是否會造成主線程雍塞，影響用戶使用

另一個要關注的點是使用後是否會造成阻塞的狀況，由於主線程雍塞的議題已經不是一兩天的事，這裡就簡單整理大神所提到的重點
ASP.NET async 基本心法
閱讀筆記 - 使用 .NET Async/Await 的常見錯誤
.NET 程式鎖死與 SynchronizationContext
或是參考由強者前同事所撰寫的電子書 : .NET 本事－非同步程式設計 :)

感想
魔鬼藏在細節裡。以上就針對 Task.WaitAll 與 Task.WhenAll 做更進一步的說明，以及在討論時所提到的兩個主要的差異內容，這些細節如果一沒有注意到勢必會造成很大的影響，在開發使用也請多加留意或是查相關資料。

參考
C# Thread: What is the difference between Task.WaitAll & Task.WhenAll
Why doesn't await on Task.WhenAll throw an AggregateException?
Task.WhenAll Method
Task.WhenAll - Inner exceptions are lost

Read More

[NET] Task 等待多個任務 - Task.WaitAll 與 Task.WhenAll

前言 
在開發偶爾會遇到需要起多個 Task ，接著等待這些 Task 都完成在去做後續邏輯處理，.NET 中提供 Task.WaitAll 與 Task.WhenAll 靜態方法來知道所有任務是否執行完成，過去自己對於兩者的差異性不太明白，因此這篇文章整理自己對於兩者的相關資訊與用法，希望有不清楚或是自己研究錯誤的地方歡迎提出討論

探索問題
Task.WaitAll
在以下的 Sample Code 中使用 Task.Run 建立三個 Task 分別 sleep 1、2、3 秒鐘，接著使用 Task.WaitAll 方法來知道三者是否已執行完成 

static void Main(string[] args)
{
    Task Task1 = Task.Run(() => Thread.Sleep(1000));
    Task Task2 = Task.Run(() => Thread.Sleep(2000));
    Task Task3 = Task.Run(() => Thread.Sleep(3000));

    Task.WaitAll(Task1, Task2, Task3);

    // todo something..
}

在 Task.WaitAll 有提供另一組 API ，可以限定想要等待的時間秒數才不用一直無止境等待下去，這裡在原本的 sample code 再加上等待時間 2.5 秒及透過 Task.IsCompleted 顯示各自是否已完成

static void Main(string[] args)
{
    Task Task1 = Task.Run(() => Thread.Sleep(1000));
    Task Task2 = Task.Run(() => Thread.Sleep(2000));
    Task Task3 = Task.Run(() => Thread.Sleep(3000));

    Task.WaitAll(new Task[] {Task1, Task2, Task3 }, 2500);

    Console.WriteLine("Task1.IsCompleted:{0}", Task1.IsCompleted);
    Console.WriteLine("Task2.IsCompleted:{0}", Task2.IsCompleted);
    Console.WriteLine("Task3.IsCompleted:{0}", Task3.IsCompleted);
}

// result 
// Task1.IsCompleted:True
// Task2.IsCompleted:True
// Task3.IsCompleted:False

在非同步情境時使用 WaitAll 會阻礙執行緒或鎖定 ( blocks thread )，會造成在所有的工作結束之前，當前使用到的執行緒無法自由處理其他工作，在此篇 How and Where Concurrent Asynchronous I/O with ASP.NET Web API 文章有提到，如果某項任務無法正確執行最後引起 deadlocks 狀況發生，此時需要使用 ConfigureAwait 來避免執行緒 lock，更詳細的內容可以參考 Best Practices in Asynchronous Programming。

Task.WhenAll
另一個等待所有任務完成的方法是 Task.WhenAll，使用的 Sample Code 中是相同於上述代碼，使用方式不難，在 MSDN Task.Whenall 方法簽章可以看到，使用 Task.WhenAll 方法時會回傳 Task，因此與剛剛差異的是其中等待完成任務方法使用 WhenAll 進行，在使用一個 taskWhenAll 變數用 wait 方法等待完成

static void Main(string[] args)
{
    Task Task1 = Task.Run(() => Thread.Sleep(1000));
    Task Task2 = Task.Run(() => Thread.Sleep(2000));
    Task Task3 = Task.Run(() => Thread.Sleep(3000));

    var taskWhenAll = Task.WhenAll(Task1, Task2, Task3);

    taskWhenAll.Wait();
}

在執行到 Task.WhenAll 時候，會新增一個 Task 並等待該任務的結果 (自己理解上是有專門 Task 在 handle 後續處理)，因此使用 WhenAll 不會造成執行緒阻礙的情況發生

Task.WaitAll v.s Task.WhenAll

上面分別介紹兩者的用法與說明，但光看文字與簡單代碼還不過癮，因此小弟參考網路上資料針對 WaitAll 與 WhenAll 執行時間做比較讓數據說話，sample Code 如下

public class Program
{
    static void Main(string[] args)
    {
        IEnumerable<Worker> workerObjects = new List<Worker>
        {
            new Worker {Id = 1, SleepTimeout = 1000},
            new Worker {Id = 2, SleepTimeout = 2000},
            new Worker {Id = 3, SleepTimeout = 3000},
            new Worker {Id = 4, SleepTimeout = 4000},
            new Worker {Id = 5, SleepTimeout = 5000},
        };

        // WaitAll
        TaskWaitAll(workerObjects);

        // WhenAll
        var task = TaskWhenAll(workerObjects);
        
        Console.ReadKey();
    }

    static void TaskWaitAll(IEnumerable<Worker> workers)
    {
        var startTime = DateTime.Now;
        Console.WriteLine("Starting : Task.WaitAll...");

        Task.WaitAll(workers.Select(worker => worker.DoWork(startTime)).ToArray());

        var endTime = DateTime.Now;
        Console.WriteLine("Test finished after {0:F2} seconds.\n", (endTime - startTime).TotalSeconds);
    }

    static Task TaskWhenAll(IEnumerable<Worker> workers)
    {
        var startTime = DateTime.Now;
        Console.WriteLine("Starting test: Task.WhenAll...");

        var task = Task.WhenAll(workers.Select(worker => worker.DoWork(startTime)));
        task.Wait();

        var endTime = DateTime.Now;
        Console.WriteLine("Test finished after {0:F2} seconds.\n", (endTime - startTime).TotalSeconds);

        return task;
    }
}

public class Worker
{
    public int Id;
    public int SleepTimeout;

    public async Task DoWork(DateTime testStart)
    {
        var workerStart = DateTime.Now;
        Console.WriteLine("Worker {0} started on thread {1}, beginning {2:F2} seconds after test start.", Id, Thread.CurrentThread.ManagedThreadId, (workerStart - testStart).TotalSeconds);

        await Task.Run(() => Thread.Sleep(SleepTimeout));

        var workerEnd = DateTime.Now;
        Console.WriteLine("Worker {0} stopped; the worker took {1:F2} seconds, and it finished {2:F2} seconds after the test start.", Id, (workerEnd - workerStart).TotalSeconds, (workerEnd - testStart).TotalSeconds);
    }
}

簡單說明 sample code 內容

• Worker 類別 : 提供 doWork async方法透過 task.run 執行 thread.sleep，可傳入要 sleep 時間與 id，執行前後分別記錄起始、結束時間 
• main : 主要測試程式進入點，做三件事情
• 初始化測試的 workerObjects，建立五筆 worker instance 分別測試 1~5 秒
• 執行測試  TaskWaitAll、TaskWhenAll 方法 
• TaskWaitAll 方法，裡面紀錄 waitAll 方法起始與結束的時間
• TaskWhenAll 方法，裡面紀錄 whenAll 方法起始與結束的時間 

執行結果

從以下得知 Task.WaitAll 執行時間為 5.07 秒，Task.WhenAll 執行時間為 5.01 秒
執行多次時間比較都是 WhenAll 會優於 WaitAll，有興趣的客官可以自行下載試試

後記
為了避免執行緒阻塞的情形發生，使用上建議 Task.WhenAll 來取代 Task.WaitAll，從最後的簡單測試代碼執行時間比較來看也是 WhenAll 會優於 WaitAll，其中為了比較 Task.waitAll 與 Task.whenAll 差異性閱讀很多相關的文章與 blog，花了很多時間才產生這篇文章，希望可以透過以上的說明能幫助到有需要的網友(咦 誰是你網友)，如果文章中有謬誤或不正確的部分，也請各位大大給予正確指教，最後推薦 MSDN 文章 : Best Practices in Asynchronous Programming 讀完對這方面會很有幫助，謝謝

參考
Async/Await - Best Practices in Asynchronous Programming
Using async/await for multiple tasks
How and Where Concurrent Asynchronous I/O with ASP.NET Web API
await, WhenAll, WaitAll, oh my!!

Using Stopwatch and ContinueWith to Measure Task Execution Time in C#

Async/Await - Best Practices in Asynchronous Programming

Read More