1. はじめに
基本から始めます。キューは基本的なデータ構造で、FIFO (First-In, First-Out)、つまり「先に入ったものが先に出る」方式で動きます。スーパーの列を想像してください:先に並んだ人が先にサービスを受けます。
マルチスレッドプログラミングでは、Producer-Consumer(生産者-消費者)パターンは非常に一般的で強力です。
- Producers(プロデューサー) — データやタスクを生成して共有キューに入れるスレッドやアプリケーションの部分。仕事を「生成」します。
- Consumers(コンシューマー) — キューからデータやタスクを取り出して処理するスレッドやアプリケーションの部分。仕事を「消費」します。
このパターンはデータの流れを管理し、コンポーネントを疎結合にします(プロデューサーは誰がどう処理するかを知らなくていい)。アプリをより応答性の高いものにし、スレッド間で負荷を均等に分散するのに役立ちます。
例: ConcurrentQueue — 追加と取り出し
ConcurrentQueue<T>に要素を追加して取り出す方法を見てみましょう。
using System.Collections.Concurrent;
ConcurrentQueue<string> tasks = new ConcurrentQueue<string>();
// 要素の追加(プロデューサー)
tasks.Enqueue("ファイルをダウンロードする");
tasks.Enqueue("画像を処理する");
Console.WriteLine($"キュー内のタスク数: {tasks.Count}"); // 出力: キュー内のタスク数: 2
// 要素の取り出し(コンシューマー)
if (tasks.TryDequeue(out string task1))
{
Console.WriteLine($"タスク実行済み: {task1}"); // 出力: タスク実行済み: ファイルをダウンロードする
}
if (tasks.TryDequeue(out string task2))
{
Console.WriteLine($"タスク実行済み: {task2}"); // 出力: タスク実行済み: 画像を処理する
}
if (!tasks.TryDequeue(out string emptyTask))
{
Console.WriteLine("キューは空です、新しいタスクはありません。"); // 出力: キューは空です、新しいタスクはありません。
}
基本操作: Enqueue(), TryDequeue()
Enqueue(T item): 要素をキューの末尾に追加するために使います。この操作はスレッドセーフです。異なる10個のスレッドから同時に Enqueue を呼んでも、すべての要素は正しく追加されます。
TryDequeue(out T item): キューの先頭から要素を取り出そうとするために使います。これはコンシューマーにとって重要なメソッドです。要素が正常に取り出された場合はtrue を返し(取り出した値は出力パラメータ item に入る)、キューが空の場合はfalse を返します。重要なのは、TryDequeue はキューが空のときにスレッドをブロックしない点です。
2. TryDequeue() の重要性と操作のアトミック性
TryDequeue() は単に便利なだけでなく、正しいスレッドセーフな動作にとって極めて重要です。これはアトミックです:キューが空かどうかのチェックと実際の取り出しが一つの分割不可能な操作として行われます。
もし IsEmpty(キューが空か確認)と Dequeue(要素を取り出す) のような別々のメソッドしかなかったら、これらの呼び出しの間に別のスレッドがキューを空にしてしまう可能性があります。その結果、あなたの Dequeue は例外を投げたり不正なデータを返したりするでしょう。TryDequeue はそのような状況を完全に排除します。
例: 複数スレッドのProducer-Consumer
ここでは2つのプロデューサースレッドと1つのコンシューマースレッドを起動します。
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;
ConcurrentQueue<int> dataQueue = new ConcurrentQueue<int>();
bool producersDone = false; // コンシューマーに知らせるフラグ
void Producer(int start, int count)
{
for (int i = 0; i < count; i++)
{
dataQueue.Enqueue(start + i);
Console.WriteLine($"[P] 追加: {start + i}");
Thread.Sleep(10);
}
}
void Consumer()
{
while (!producersDone || dataQueue.Count > 0) // データがあるかプロデューサーが動いている間続ける
{
if (dataQueue.TryDequeue(out int item))
{
Console.WriteLine($"[C] 処理済み: {item}");
}
else
{
Thread.Sleep(50); // キューが空なら待つ
}
}
Console.WriteLine("[C] 作業完了。");
}
// Mainでの実行例:
// Task.Run(() => Producer(1, 5));
// Task.Run(() => Producer(100, 5)); // 2つ目のプロデューサー
// Task.Run(() => Consumer());
// Thread.Sleep(600); // スレッドに作業時間を与える
// producersDone = true; // プロデューサーが終わったことを通知
// Thread.Sleep(200); // コンシューマーが残りを取り出す時間を与える
このシンプルな例では、フラグ producersDone と Thread.Sleep は終了のシミュレーションに使われています。実際のアプリでは、完了の同期には CancellationTokenSource や BlockingCollection<T> がよく使われます。
ConcurrentQueue<T> は次のようなシナリオに最適です:
- 要素の処理順が重要(FIFO)。
- 複数のスレッドが要素を追加し、または複数のスレッドが取り出す場合。
- ロックを手動で管理せずに高パフォーマンスが必要な場合。
3. Producer-Consumerのためのスタック(LIFO)
スタックは別の基本的なデータ構造で、LIFO (Last-In, First-Out)、つまり「最後に入ったものが最初に出る」方式で動きます。皿の山を想像してください:常に一番上の皿を取りますし、新しい皿は常に山の一番上に置きます。
ConcurrentStack<T> は ConcurrentQueue<T> と同様にスレッドセーフで、処理順が逆のProducer-Consumerパターンに使えます。
例: ConcurrentStack — 追加と取り出し
using System.Collections.Concurrent;
ConcurrentStack<string> commandStack = new ConcurrentStack<string>();
// コマンドの追加(プロデューサー)
commandStack.Push("テキストを選択する");
commandStack.Push("フォントを変更する");
commandStack.Push("ドキュメントを保存する");
Console.WriteLine($"スタック内のコマンド数: {commandStack.Count}"); // 出力: スタック内のコマンド数: 3
// コマンドの取り出し(コンシューマー)
if (commandStack.TryPop(out string cmd1))
{
Console.WriteLine($"取り消したコマンド: {cmd1}"); // 出力: 取り消したコマンド: ドキュメントを保存する
}
if (commandStack.TryPop(out string cmd2))
{
Console.WriteLine($"取り消したコマンド: {cmd2}"); // 出力: 取り消したコマンド: フォントを変更する
}
if (!commandStack.TryPop(out string emptyCmd))
{
Console.WriteLine("コマンドスタックは空です。"); // 出力: コマンドスタックは空です。
}
4. 基本操作: Push(), TryPop()
Push(T item): 要素をスタックの頂上に追加するために使います。操作はスレッドセーフです。
TryPop(out T item): スタックの頂上から要素を取り出そうとするために使います。要素が正常に取り出されたらtrue を返し、スタックが空ならfalse を返します。TryDequeue と同様に、これはアトミック操作でデータレースを防ぎます。
例: オブジェクトプールにConcurrentStackを使う
スタックはオブジェクトプールの実装に適しています:取る — 使う — 返す。
using System.Collections.Concurrent;
class Connection { /* 単純なダミー */ public Guid Id { get; } = Guid.NewGuid(); }
ConcurrentStack<Connection> connectionPool = new ConcurrentStack<Connection>();
// 初期接続でプールを満たす
for (int i = 0; i < 3; i++)
{
connectionPool.Push(new Connection());
}
Console.WriteLine($"プール内の接続数: {connectionPool.Count}"); // 出力: プール内の接続数: 3
void UseConnection()
{
if (connectionPool.TryPop(out Connection conn))
{
Console.WriteLine($"[Pool] 使用した接続: {conn.Id}");
// 接続を使う模擬
Thread.Sleep(50);
connectionPool.Push(conn); // プールに返す
Console.WriteLine($"[Pool] 返却した接続: {conn.Id}. プール内: {connectionPool.Count}");
}
else
{
Console.WriteLine("[Pool] 接続プールが空です。新しく作成します。");
// 通常はプールが空なら新しい接続を作る
connectionPool.Push(new Connection());
}
}
// Mainでの実行例:
Task.Run(() => UseConnection());
Task.Run(() => UseConnection());
Task.Run(() => UseConnection());
Thread.Sleep(500);
この例では、複数のスレッドが安全に共有プールから接続を取り出して返却できます。
5. 適用例と ConcurrentQueue との比較
ConcurrentStack<T> は次のようなときに使われます:
- LIFO の順序が重要な場合(例:Undoの操作履歴)。
- 最近追加された要素に素早くアクセスしたい場合(キャッシュ内で「ホット」なことが多い)。
- スタックベースのアルゴリズム(深さ優先探索、式の構文解析など)を実装する場合。
比較と適切なコレクションの選択
| コレクション | 順序 | 利点 | 典型的なシナリオ |
|---|---|---|---|
|
FIFO(先に入ったものが先に出る) | 到着順に公正な処理を保証する | タスクキュー、ロギング、受信リクエスト処理、イベントバス |
|
LIFO(最後に入ったものが最初に出る) | 最近追加された要素への高速アクセス | 操作履歴(Undo/Redo)、オブジェクトプール、探索アルゴリズム(DFS) |
Producer-Consumerシナリオで ConcurrentQueue と ConcurrentStack のどちらを選ぶかは、要素の処理順次第です。どちらのコレクションも「箱から出してすぐに」高いパフォーマンスとスレッドセーフ性を提供するので、手動の同期を気にせずスケーラブルなマルチスレッドシステムを構築できます。
GO TO FULL VERSION