1. 入門
今日は、利用可能なプロセッサコアすべてを使って大量データをできるだけ速く処理する方法を見ていくよ(PCやサーバーで)。そのために System.Threading.Tasks.Parallel 名前空間のクラス、特に Parallel.For と Parallel.ForEach が役に立つ。
タスクが純粋な CPU-bound の場合はどうする?
通常の for や foreach ループは要素を一つずつ処理する。シンプルで確実。でもマルチコアCPUだとループは1コアしか使わないから、残りのコアが遊んでいることになる。配列の部分を別々のコアに割り当てて同時に処理できないかな?
例:
// 1 から N までの二乗の合計を計算する
long sum = 0;
for (int i = 1; i <= 1_000_000; i++)
{
sum += i * i;
}
このコードはシンプルだけど逐次的に動く。もしタスクをコアに分散させたらどうなるかな?
ファミリーの紹介: Parallel.For と Parallel.ForEach
これは何?
- Parallel.For — 通常の for と同じように動くけど、作業をチャンクに分けてスレッドに自動で割り当て、利用可能なコアを使う。
- Parallel.ForEach — コレクションを通常の foreach のように処理するが、こちらも並列で実行する。
公式ドキュメント:
なぜ便利?
自分でスレッドを作ったり起動したり管理する必要がない。フレームワークが重い部分をやってくれる。普段のループに似たコードを書くだけで、裏側で並列化が行われる。
2. 構文: 基本例
Parallel.For
long total = 0;
Parallel.For(1, 1_000_001, i =>
{
// このラムダは異なるスレッドで同時に実行される可能性がある
Interlocked.Add(ref total, i * i); // レースを避けるため
});
Console.WriteLine($"二乗の合計: {total}");
注意: 変数 total は Interlocked.Add を経由して更新している — データ競合を避けるためだよ。
Parallel.ForEach
var numbers = Enumerable.Range(1, 10_000_000).ToArray();
long sum = 0;
Parallel.ForEach(numbers, num =>
{
Interlocked.Add(ref sum, num * num); // 安全な加算
});
Console.WriteLine($"二乗の合計: {sum}");
内部の様子(ビジュアル図)
+-------------------+
|コレクション/範囲 |
+---------+---------+
|
v
+----------------------+
| Parallel.ForEach |
+----------+-----------+
|
+----+----+----+----+
| | |
v v v
Task #1 Task #2 Task #3 ... (利用可能なコア)
| | |
+--+----+ +--+-----+ +--+-----+
|処理 | |処理 | |処理 |
+-------+ +--------+ +--------+
\ | /
+--------+--------+
|
v
結果
3. 大きなファイルの解析(CPU-bound 処理)
数万行のテキストファイルがあって、各行が数値になっているとする。ファイルを読み込んで、各数値を二乗して二乗和を求める必要があるとする。
同期版
string[] lines = File.ReadAllLines("numbers.txt");
long sum = 0;
foreach (var line in lines)
{
if (long.TryParse(line, out long n))
{
sum += n * n;
}
}
Console.WriteLine($"二乗の合計: {sum}");
Parallel.For を使った並列版
string[] lines = File.ReadAllLines("numbers.txt");
long sum = 0;
Parallel.For(0, lines.Length, i =>
{
if (long.TryParse(lines[i], out long n))
{
Interlocked.Add(ref sum, n * n);
}
});
Console.WriteLine($"二乗の合計: {sum}");
何が変わったか: 通常のループを並列ループに置き換え、sum を Interlocked.Add 経由で増やすようにした — スレッド間の競合を避けるためだ。
4. 裏側で何が起きている?
Parallel.For や Parallel.ForEach を呼ぶと、.NET は自動的に作業をフラグメントに分割し、スレッドプールを使って利用可能なプロセッサコアに割り当てる。各フラグメントはそれぞれのスレッドで独立に処理される。
利点: 例えば4コアなら、外部リソースに依存せずメモリやI/Oにボトルネックがなければ、ほぼ4倍速くなることがある。
実行時間の比較
var numbers = Enumerable.Range(1, 100_000_000).ToArray();
long sumSync = 0;
var sw = System.Diagnostics.Stopwatch.StartNew();
foreach (var n in numbers)
sumSync += n * n;
sw.Stop();
Console.WriteLine($"Sync: {sw.ElapsedMilliseconds} ms, 合計: {sumSync}");
long sumParallel = 0;
sw.Restart();
Parallel.ForEach(numbers, n =>
Interlocked.Add(ref sumParallel, n * n)
);
sw.Stop();
Console.WriteLine($"Parallel: {sw.ElapsedMilliseconds} ms, 合計: {sumParallel}");
ぜひ自分で試してみて! 強力なマシンでは加速が大きく出ることがあるが、実際にはタスクやボトルネック次第だ。
5. 役立つポイント
並列度の制御
時々、使用するスレッド数を制限したほうがいい場合がある(例えばシステムを過負荷にしたくない時)。その場合は MaxDegreeOfParallelism を使う:
using System.Threading.Tasks;
long sum = 0;
var options = new ParallelOptions {
MaxDegreeOfParallelism = 2
};
Parallel.For(0, 100, options, i =>
{
Interlocked.Add(ref sum, i * i);
});
Console.WriteLine($"二乗の合計: {sum}");
どんな時に有用か: 計算の一部がディスク負荷を強くかける場合は、スレッド数を少なめにして性能への影響を評価するといい。
いつ並列ループを使うべきか
| 通常の for | Parallel.For/Parallel.ForEach | |
|---|---|---|
| プロセッサ | 1コアを使用 | 全コアを使用 |
| 順序 | 保証される | 保証されない |
| 速度 | 通常は遅い | しばしば大幅に速い |
| 簡単さ | とても簡単 | スレッドセーフを考慮する必要あり |
| 最適な適用 | 小さいデータ量、I/O-bound | 大きいデータ量、CPU-bound |
拡張: Parallel は他に何ができる?
Parallel.Invoke() — 複数の独立したメソッドを同時に起動できる:
static void DoTask1() => Console.WriteLine("タスク 1 完了");
static void DoTask2() => Console.WriteLine("タスク 2 完了");
static void DoTask3() => Console.WriteLine("タスク 3 完了");
Parallel.Invoke(
() => DoTask1(),
() => DoTask2(),
() => DoTask3()
);
それぞれのメソッドは可能なら別のコアで実行される。
実務での利用例
- 画像処理: 異なるブロックを同時に処理(フィルタ適用など)。
- 配列演算: 金融計算、モデリング(シナリオごとのポートフォリオ評価)。
- 大きなログの処理: 検索や集計を複数コアで並列に行う。
- 機械学習: 独立タスクへの分割(データバッチ、feature engineering)。
そして面接でも、並列ループが何かを説明できるだけでなく、その利点と欠点を正直に語れるようになるはずだ。
6. Parallel.For と Parallel.ForEach を使うときの典型的なミス
ミス #1: データ競合を無視すること。
共有変数を Interlocked や lock なしで更新すると、複数スレッドの同時アクセスで結果が壊れる。
ミス #2: I/O-bound タスクに使うこと。
並列ループはディスクやネットワーク依存のタスクを速くしないことが多く、オーバーヘッドで遅くなる可能性がある。
ミス #3: 実行順序を期待すること。
並列ループは要素処理の順序を保証しないので、順序に依存するロジックだと壊れる。
ミス #4: 副作用を無視すること。
並列ループ内で共有コレクションなどの状態を変更すると、スレッドセーフな構造を使わない限りエラーになる可能性がある。
GO TO FULL VERSION