1
1

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

Task.WhenAllで1つの処理が失敗したら、ほかの処理はどうなるの?|C#非同期処理の例外を理解しよう

1
Posted at

はじめに

前回の記事では、Task.WhenAll を使って、複数の非同期処理の完了をまとめて待つ方法を紹介しました。

例えば、次のようなコードです。

Task taskA = GetDataAsync("A");
Task taskB = GetDataAsync("B");
Task taskC = GetDataAsync("C");

await Task.WhenAll(taskA, taskB, taskC);

3つの非同期処理を先に開始し、すべての完了をまとめて待っています。

では、ここで一つ疑問があります。

3つの処理のうち、1つだけ例外が発生したら、ほかの処理はどうなるのでしょうか?

  • 例外が発生した時点で、すべての処理が止まる?
  • ほかの処理は、そのまま動き続ける?
  • catch では、どの例外を受け取る?

今回は、実際に動くコードで確認しながら、Task.WhenAll の例外処理を整理していきます。


1. 1つのTaskが失敗したらどうなる?

まずは、3つの非同期処理を実行してみましょう。

今回は Task.Delay() を使って、時間のかかる非同期処理を再現します。

また、処理Bだけが例外を発生させるようにします。

using System;
using System.Threading.Tasks;

class Program
{
    static async Task Main()
    {
        Task taskA = DoWorkAsync("A", 1000);
        Task taskB = DoWorkAsync("B", 2000, shouldFail: true);
        Task taskC = DoWorkAsync("C", 3000);

        try
        {
            await Task.WhenAll(taskA, taskB, taskC);
        }
        catch (Exception ex)
        {
            Console.WriteLine($"例外を捕捉: {ex.Message}");
        }

        Console.WriteLine("すべてのTaskが終了しました");
    }

    static async Task DoWorkAsync(
        string name,
        int delayMilliseconds,
        bool shouldFail = false)
    {
        Console.WriteLine($"処理{name} 開始");

        await Task.Delay(delayMilliseconds);

        if (shouldFail)
        {
            Console.WriteLine($"処理{name} 失敗");

            throw new InvalidOperationException(
                $"処理{name}でエラーが発生しました");
        }

        Console.WriteLine($"処理{name} 完了");
    }
}

実行結果は、次のようになります。

処理A 開始
処理B 開始
処理C 開始
処理A 完了
処理B 失敗
処理C 完了
例外を捕捉: 処理Bでエラーが発生しました
すべてのTaskが終了しました

注目したいのは、処理Bが失敗したあとです。

処理Bは約2秒後に例外を発生させています。

しかし、処理Cは途中で止まらず、約3秒後に正常終了しています。

時間 →

処理A  [====1秒====] 完了

処理B  [========2秒========] 例外発生

処理C  [============3秒============] 完了

                                      ↓
                                  catchへ進む

つまり、Task.WhenAll は、1つのTaskが失敗しても、ほかのTaskを自動的に停止しません。

これが、今回最初に覚えておきたいポイントです。


2. Task.WhenAllはいつ完了する?

では、なぜ処理Bが失敗した時点で catch に進まなかったのでしょうか?

理由は、Task.WhenAll の役割にあります。

Task.WhenAll は、渡されたすべてのTaskが終了したときに完了するTaskを返します。

今回の場合は、次の3つです。

Task 終了時間 結果
処理A 約1秒後 正常終了
処理B 約2秒後 例外発生
処理C 約3秒後 正常終了

処理Bが失敗した時点では、処理Cがまだ実行中です。

そのため、Task.WhenAll が返したTaskは、まだ完了しません。

処理Cも終了したあと、Task.WhenAll が返したTaskは例外を持つ状態になります。

そして、await によって例外が通知され、catch に進みます。

Task.WhenAllが返すTaskの状態

Task.WhenAll が返すTaskの状態は、各Taskの結果によって変わります。

各Taskの結果 WhenAllが返すTaskの状態
すべて正常終了 RanToCompletion
1つ以上が例外で終了 Faulted
例外はなく、1つ以上がキャンセル Canceled

例えば、処理Bが失敗し、処理Cがキャンセルされた場合でも、例外で終了したTaskがあるため、Task.WhenAll の結果は Faulted になります。

Task.WhenAll は、最初に失敗したTaskを見つけた時点で終了する仕組みではありません。

すべてのTaskが終了してから、結果が決まるのです。


3. 2つ以上のTaskが失敗したらどうなる?

ここまでは、処理Bだけが失敗する例でした。

では、処理Bと処理Cの両方が失敗した場合はどうなるでしょうか?

第1章の Main() を、次のように変更してみます。

static async Task Main()
{
    Task taskA = DoWorkAsync("A", 1000);
    Task taskB = DoWorkAsync("B", 2000, shouldFail: true);
    Task taskC = DoWorkAsync("C", 3000, shouldFail: true);

    try
    {
        await Task.WhenAll(taskA, taskB, taskC);
    }
    catch (Exception ex)
    {
        Console.WriteLine($"例外を捕捉: {ex.Message}");
    }
}

※ DoWorkAsync() は第1章と同じものを使用します。

実行結果の一例です。

処理A 開始
処理B 開始
処理C 開始
処理A 完了
処理B 失敗
処理C 失敗
例外を捕捉: 処理Bでエラーが発生しました

処理Bと処理Cの両方で例外が発生しています。

しかし、catch で表示された例外は1つだけです。

ここで疑問が出てきます。

処理Cの例外は、どこへ行ったのでしょうか?

実は、なくなったわけではありません。

Task.WhenAll が返したTaskには、両方の例外情報が保持されています。

ただし、通常の await では、そのうちの1つの例外が通知されます。

そのため、catch (Exception ex) で受け取った例外だけを確認しても、すべての失敗を把握できない場合があるのです。


4. 複数の例外を確認するには?

複数のTaskで発生した例外を確認するには、どうすればよいのでしょうか?

ポイントは、Task.WhenAll が返すTaskを変数に保持しておくことです。

static async Task Main()
{
    Task taskA = DoWorkAsync("A", 1000);
    Task taskB = DoWorkAsync("B", 2000, shouldFail: true);
    Task taskC = DoWorkAsync("C", 3000, shouldFail: true);

    Task allTasks = Task.WhenAll(taskA, taskB, taskC);

    try
    {
        await allTasks;
    }
    catch (Exception ex)
    {
        Console.WriteLine($"awaitで捕捉: {ex.Message}");

        if (allTasks.Exception is not null)
        {
            foreach (Exception innerException
                     in allTasks.Exception.InnerExceptions)
            {
                Console.WriteLine(
                    $"発生した例外: {innerException.Message}");
            }
        }
    }
}

※ DoWorkAsync() は第1章と同じものを使用します。

実行結果の一例です。

処理A 開始
処理B 開始
処理C 開始
処理A 完了
処理B 失敗
処理C 失敗
awaitで捕捉: 処理Bでエラーが発生しました
発生した例外: 処理Bでエラーが発生しました
発生した例外: 処理Cでエラーが発生しました

ここで使っているのが、allTasks.Exception です。

Taskの Exception プロパティには、例外で終了したTaskの例外情報が AggregateException として保持されます。

その InnerExceptions を確認すると、複数の例外を取得できます。

foreach (Exception ex in allTasks.Exception.InnerExceptions)
{
    Console.WriteLine(ex.Message);
}

※ Exception プロパティが null の場合もあるため、実際には null を確認してから参照します。

awaitとTask.Exceptionの違い

確認方法 内容
await allTasks 失敗した場合、保持されている例外のうち1つが通知される
allTasks.Exception Taskに保持されている例外情報を確認できる
allTasks.Exception.InnerExceptions 複数の例外を列挙できる

ここで重要なのは、await が例外を消しているわけではないということです。

await で受け取る例外と、Taskに保持されている例外情報は、確認の仕方が異なるのです。

なお、どの例外が await で通知されるかについて、例外の発生順に依存した処理を書くべきではありません。

複数の失敗を確認する必要がある場合は、InnerExceptions を確認するようにしましょう。


5. 1つが失敗したら、ほかの処理も止めたい場合は?

ここまで見てきたように、Task.WhenAll は、1つのTaskが失敗しても、ほかのTaskを自動的には止めません。

しかし、実務では、失敗した時点でほかの処理を続ける必要がなくなる場合もあります。

例えば、画面表示に必要な複数のデータを取得しているときです。

  • ユーザー情報を取得する
  • 商品情報を取得する
  • お知らせ情報を取得する

もしユーザー情報の取得に失敗したら、ほかの取得処理も不要になる設計かもしれません。

そのような場合は、CancellationToken を使ったキャンセル制御などを検討します。

ただし、CancellationToken を渡しただけでは、1つのTaskの失敗を検知してほかのTaskが自動的にキャンセルされるわけではありません。

失敗を検知してキャンセルを要求する仕組みと、各処理がキャンセル要求に対応する実装が必要です。

また、すでに完了した処理をキャンセルで取り消すことはできません。

Task.WhenAll は複数のTaskの完了を待つ仕組み。

CancellationToken はキャンセル要求を伝える仕組み。

それぞれ役割が違うことを覚えておきましょう。

キャンセルの基本的な仕組みについては、以前のCancellationTokenの記事でも解説しています。


6. 実務で気をつけたいポイント

① 例外が発生しても、すぐにcatchへ進むとは限らない

Task.WhenAll は、渡されたすべてのTaskが終了するまで待ちます。

そのため、1つのTaskが早い段階で失敗しても、ほかのTaskが長時間実行されていれば、await Task.WhenAll() から戻るまで時間がかかります。

画面の応答性やタイムアウトを考える場合は、この動作に注意が必要です。

② 複数の失敗をログに残す

複数のTaskが失敗する可能性がある場合、catch で受け取った例外だけでは、すべての失敗を把握できないことがあります。

必要に応じて、Task.WhenAll が返したTaskの Exception プロパティを確認します。

また、どの処理で失敗したのか分かるように、処理名などの情報もログに残しておくと、原因調査に役立ちます。

③ 失敗後の動作はアプリケーション側で決める

1つのTaskが失敗したとき、ほかの処理を続けるべきかどうかは、処理の目的によって変わります。

独立した処理なら、一部が失敗しても、ほかの結果を利用できる場合があります。

一方、すべての結果が揃わなければ意味がない処理なら、ほかの処理をキャンセルする設計も考えられます。

Task.WhenAll が、続行するかキャンセルするかを自動的に判断してくれるわけではありません。


7. まとめ

今回のポイントを整理します。

ポイント 内容
1つのTaskが失敗 ほかのTaskは自動的には止まらない
Task.WhenAll の完了 渡されたすべてのTaskが終了してから
await の例外 複数の失敗があっても、通常は1つの例外が通知される
Task.Exception Taskに保持されている例外情報を確認できる
InnerExceptions 複数の例外を列挙できる
キャンセル CancellationToken などを使って別途制御する

Task.WhenAll は、複数の非同期処理をまとめて待つための仕組みです。

しかし、1つのTaskが失敗したからといって、ほかのTaskまで自動的に止めてくれるわけではありません。

また、複数のTaskが失敗した場合、await で受け取った例外だけでは、すべての失敗を把握できないことがあります。

最後に、今回覚えておきたいことは3つです。

  1. Task.WhenAll は、1つが失敗しても、ほかのTaskの終了を待つ。
  2. 複数の例外を確認したい場合は、Task.WhenAll が返したTaskの Exception を確認する。
  3. 失敗時にほかの処理を止めるかどうかは、アプリケーション側で設計する。

複数の非同期処理をまとめて実行するときは、正常終了する場合だけでなく、**途中で1つが失敗したらどうなるか?**も考えてみてください。


関連記事

C#の非同期処理について、こちらの記事でも解説しています。

これまでの記事は、Qiitaのプロフィールページからご覧いただけます。

1
1
2

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
1
1

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?