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を使えば処理は速くなるの?|C#非同期処理の並行実行を理解しよう

1
Posted at

はじめに

画面を表示するときに、次の3つのデータを取得する場面を考えてみます。

  • ユーザー情報
  • 商品情報
  • お知らせ情報

それぞれの取得に約1秒かかるとします。

順番に取得すると、合計で約3秒。

でも、この3つのデータに依存関係がなければ、わざわざ順番に待つ必要はあるのでしょうか?

C#には、複数の非同期処理をまとめて待つための Task.WhenAll があります。

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

これを使えば、処理時間を短くできる場合があります。

ただし、Task.WhenAll 自体が処理を高速化しているわけではありません。

では、なぜ処理時間が短くなるのでしょうか?

今回は、3つの書き方を比較しながら、その仕組みを整理していきます。


1. 順番にawaitするとどうなる?

まずは、3つのデータを順番に取得する場合です。

今回は処理の違いを分かりやすくするため、実際の通信処理の代わりに Task.Delay() を使います。

static async Task GetDataAsync(string name)
{
    Console.WriteLine($"{name} 開始");

    await Task.Delay(1000);

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

static async Task Main()
{
    await GetDataAsync("ユーザー情報");
    await GetDataAsync("商品情報");
    await GetDataAsync("お知らせ情報");
}

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

ユーザー情報 開始
ユーザー情報 完了
商品情報 開始
商品情報 完了
お知らせ情報 開始
お知らせ情報 完了

最初の処理が完了してから、次の処理を開始しています。

それぞれ約1秒なので、全体では約3秒かかります。

時間 →

ユーザー情報   [====1秒====]
商品情報                   [====1秒====]
お知らせ情報                            [====1秒====]

全体         [=============約3秒=============]

ここで重要なのは、await の役割です。

await は、非同期処理の完了を待ち、その結果を受け取るために使います。

しかし、await を書いたからといって、次の非同期処理まで自動的に開始されるわけではありません。

今回のコードでは、1つ目の await が完了するまで、2つ目の GetDataAsync() は呼び出されません。

そのため、処理時間が積み重なっているのです。


2. Task.WhenAllを使うとどうなる?

では、同じ処理を Task.WhenAll でまとめて待ってみます。

GetDataAsync() は先ほどと同じものを使用します。

static async Task Main()
{
    Task taskA = GetDataAsync("ユーザー情報");
    Task taskB = GetDataAsync("商品情報");
    Task taskC = GetDataAsync("お知らせ情報");

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

実行結果の一例です。

ユーザー情報 開始
商品情報 開始
お知らせ情報 開始
ユーザー情報 完了
商品情報 完了
お知らせ情報 完了

※完了時の表示順序は、実行環境によって変わる場合があります。

今度は、3つの処理を先に開始してから、まとめて完了を待っています。

時間 →

ユーザー情報   [====1秒====]
商品情報       [====1秒====]
お知らせ情報   [====1秒====]

全体           [====約1秒====]

それぞれの処理にかかる時間は変わっていません。

しかし、待機時間が重なるため、全体では約1秒で完了します。

つまり、1つずつ順番に待つのではなく、複数の非同期処理を同じ時間帯に進められることが、時間短縮の理由です。

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

本当に Task.WhenAll を使ったから速くなったのでしょうか?


3. Task.WhenAllが処理を速くしているわけではない

ここが今回の一番重要なポイントです。

次のコードを見てください。

static async Task Main()
{
    Task taskA = GetDataAsync("ユーザー情報");
    Task taskB = GetDataAsync("商品情報");
    Task taskC = GetDataAsync("お知らせ情報");

    await taskA;
    await taskB;
    await taskC;
}

先ほどのコードとの違いは、Task.WhenAll を使わず、個別に await していることです。

実は、このコードでも全体の処理時間は約1秒になります。

なぜでしょうか?

理由は、await する前に、3つの非同期処理をすべて開始しているからです。

async メソッドは、呼び出されると処理を開始し、最初の未完了の await に到達すると呼び出し元へ制御を返します。

今回の GetDataAsync() では、Task.Delay(1000) の待機中に制御が戻るため、続けて次の GetDataAsync() を呼び出せます。

その結果、3つの待機時間が重なります。

ここまでの3パターンを比較してみましょう。

書き方 処理の開始 全体の時間
① 1つずつ開始してawait 順番 約3秒
② 3つ開始してWhenAll 先にすべて開始 約1秒
③ 3つ開始して個別にawait 先にすべて開始 約1秒

※今回のように、互いに独立した約1秒の非同期待機を行う場合の目安です。

この比較から分かるのは、処理時間を短くしているのは、複数の非同期処理を先に開始していることだという点です。

では、Task.WhenAll は何をしているのでしょうか?

Task.WhenAllの本当の役割

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

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

await allTasks;

つまり、複数のTaskをまとめて管理し、その完了を待つための仕組みです。

Task.WhenAll 自体が、処理を開始したり、別スレッドで実行したりするわけではありません。

また、3つのTaskを個別に await する場合と比べて、例外やキャンセルの扱い方にも違いがあります。

単に処理時間を短くするためだけではなく、複数のTaskを一つのまとまりとして扱えることが、Task.WhenAll の利点なのです。


4. 並行実行と並列実行は同じではない

ここで、一つ注意しておきたいことがあります。

Task.WhenAll を使ったからといって、CPUの計算処理が自動的に並列実行されるわけではありません。

今回の例では、3つの Task.Delay() の待機時間が重なっています。

これは、複数の処理を同じ時間帯に進める「並行実行」の例です。

一方、複数のCPUコアなどを使い、実際に複数の計算を同時に行うことを「並列実行」といいます。

並行実行 並列実行
考え方 複数の処理を同じ時間帯に進める 複数の処理を実際に同時実行する
例 複数の通信応答を待つ 複数のCPUコアで計算する
Task.WhenAll 複数のTaskの完了をまとめて待てる 自動的に並列化するわけではない

非同期処理をまとめて待つことと、CPU処理を並列化することは別だと覚えておきましょう。


5. Task.WhenAllで効果が出る場合・出ない場合

Task.WhenAll を使って待機時間を短くできるのは、主に次のような場合です。

互いに依存しない複数の非同期処理を、同じ時間帯に進められる場合です。

例えば、独立した複数のデータ取得処理や、複数のファイルの非同期読み込みなどが考えられます。

一方、次のような場合は注意が必要です。

① 前の処理結果が必要な場合

int userId = await GetUserIdAsync();

User user = await GetUserAsync(userId);

await SaveUserAsync(user);

この例では、ユーザーIDが分からなければユーザー情報を取得できません。

また、ユーザー情報を取得しなければ保存できません。

このように、前の処理結果に依存する場合は、単純にすべての処理を先に開始することはできません。

② CPUを使う重い計算の場合

static Task CalculateAsync()
{
    HeavyCalculation();

    return Task.CompletedTask;
}

このメソッドを次のように呼び出した場合です。

Task taskA = CalculateAsync();
Task taskB = CalculateAsync();
Task taskC = CalculateAsync();

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

HeavyCalculation() は同期処理なので、メソッドを呼び出した時点で実行されます。

そのため、3つの計算は順番に実行されます。

Task.WhenAll を使っても、自動的に並列化されるわけではありません。

CPU負荷の高い計算を並列化したい場合は、Task.Run など別の仕組みを検討する必要があります。

ただし、並列化すれば必ず速くなるわけではありません。

③ 同時に実行しすぎる場合

独立した非同期処理でも、無制限に同時実行してよいわけではありません。

例えば、大量のAPIリクエストを一度に送信すると、通信先の制限やサーバー負荷によって、かえって遅くなる場合があります。

そのため、処理数が多い場合は、同時実行数を制限することも検討しましょう。


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

① 一つの処理が失敗しても、他の処理は自動的に止まらない

try
{
    await Task.WhenAll(taskA, taskB, taskC);
}
catch (Exception ex)
{
    Console.WriteLine($"エラー: {ex.Message}");
}

Task.WhenAll でまとめて待っている処理の一つが失敗しても、他の処理が自動的にキャンセルされるわけではありません。

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

また、複数のTaskが失敗した場合は、await で捕まえた例外だけでは、すべての例外を確認できないことがあります。

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

② キャンセルする場合は各処理が対応する必要がある

前回の記事では、CancellationToken を渡しただけでは処理が止まらないことを説明しました。

Task.WhenAll を使う場合も同じです。

using var cts = new CancellationTokenSource();

Task taskA = DoWorkAsync(cts.Token);
Task taskB = DoWorkAsync(cts.Token);
Task taskC = DoWorkAsync(cts.Token);

// 必要になったタイミングでキャンセルを要求する
cts.Cancel();

try
{
    await Task.WhenAll(taskA, taskB, taskC);
}
catch (OperationCanceledException)
{
    Console.WriteLine("処理がキャンセルされました");
}

※ DoWorkAsync() はキャンセルに対応した非同期メソッドを想定しています。

この例では、各処理に同じ CancellationToken を渡しています。

ただし、Cancel() を呼び出しただけでは、各処理が強制終了されるわけではありません。

それぞれの処理がキャンセル要求を確認し、対応する必要があります。

また、キャンセル要求後にすべてのTaskが必ずキャンセル状態になるとは限りません。すでに正常終了している処理や、キャンセルに対応していない処理もあるためです。

③ UIアプリケーションでは処理の独立性を確認する

WPFなどのUIアプリケーションでは、画面表示に必要な複数のデータを取得することがあります。

それぞれの取得処理が独立しているなら、先に開始してまとめて待つことで、画面表示までの待ち時間を短くできる可能性があります。

ただし、複数の処理が同じデータを書き換える場合などは注意が必要です。

また、Task.WhenAll を使っても、UI要素を別スレッドから自由に操作できるようになるわけではありません。

同じ時間帯に実行しても問題ない処理なのかを確認することが大切です。


7. まとめ

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

ポイント 内容
順番にawait 前の処理が完了してから次を開始する書き方では、待機時間が積み重なる
先に複数の処理を開始 独立した非同期処理の待機時間を重ねられる
Task.WhenAll 複数のTaskの完了をまとめて待つためのTaskを返す
並行と並列 非同期処理をまとめて待っても、CPU処理が自動的に並列化されるわけではない
注意点 処理の依存関係や同時実行数、例外・キャンセルの扱いを考える

Task.WhenAll は、処理を自動的に高速化する仕組みではありません。

今回の例で処理時間が短くなったのは、3つの非同期処理を先に開始し、それぞれの待機時間を重ねられたからです。

そして、Task.WhenAll は、その複数のTaskを一つのまとまりとして待つために使います。

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

  1. await を順番に書くと、次の処理の開始が遅れる場合がある。
  2. 独立した非同期処理を先に開始すれば、待機時間を重ねられる。
  3. Task.WhenAll は高速化の命令ではなく、複数のTaskの完了をまとめて待つ仕組み。

Task.WhenAll を使えば速くなるのか?

その答えは、どんな処理を、どのタイミングで開始するかによるということです。

処理をまとめて待つ前に、それぞれの処理を同じ時間帯に進めても問題ないかを確認してみてください。

関連記事

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

awaitは待つのに、なぜ画面は止まらないの?
async / await の基本的な仕組みを知りたい方へ。

Task.Runを使えば画面は固まらない?
Task.Run の役割と、非同期処理との違いを整理したい方へ。

CancellationTokenを渡したのに、処理が止まらないのはなぜ?
非同期処理のキャンセルの仕組みを理解したい方へ。

1
1
0

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?