C#を用いたアプリケーション開発において、データの集合を効率的に管理するためのコレクションクラスは欠かせない存在です。

その中でも「キュー (Queue)」は、「先入れ先出し (FIFO: First-In, First-Out)」というデータ構造を実現するための非常に重要なクラスです。

最初に入れたデータが最初に処理されるというシンプルな仕組みは、タスク管理やメッセージングシステム、ログのバッファリングなど、多岐にわたるシーンで活用されています。

本記事では、C#の System.Collections.Generic 名前空間に用意されている Queue<T> クラスに焦点を当て、その基本的な使い方から内部メカニズム、さらにはマルチスレッド環境下での安全な実装方法まで、プロフェッショナルな視点で詳しく解説していきます。

目次 [ close ]
  1. Queue<T>とは何か
  2. Queue<T>の基本操作
    1. 要素の追加：Enqueue
    2. 要素の取り出しと削除：Dequeue
    3. 先頭要素の参照：Peek
    4. 基本操作のコード例
  3. Queue<T>の高度な操作とプロパティ
    1. キューの状態を確認する
    2. 全要素のクリアと配列への変換
    3. メモリの最適化：TrimExcess
  4. 内部実装とパフォーマンスの理解
  5. マルチスレッド環境におけるスレッドセーフな実装
    1. ConcurrentQueue<T> の利用
    2. ConcurrentQueue<T> の実装例
  6. Queue<T> と Stack<T> の使い分け
  7. Queue<T> を活用した実践的なシナリオ
    1. 1. 非同期タスクのバッファリング
    2. 2. 幅優先探索 (BFS) の実装
    3. 3. ロギングシステム
  8. パフォーマンスを最大化するためのベストプラクティス
  9. まとめ

Queue<T>とは何か

Queue<T> は、C#のジェネリックコレクションの一つであり、特定の型 T のオブジェクトを順番に並べて保持するために設計されています。

現実世界での「行列（待ち行列）」をイメージすると分かりやすいでしょう。

例えば、レジを待つ顧客の列では、先に並んだ人から順番に会計を済ませていきます。

この 「最初に追加された要素が、最初に取り出される」 という動作が、キューの最大の特徴です。

C#において Queue<T> を使用する主なメリットは、要素の追加と削除が非常に高速に行われる点にあります。

内部的には動的配列を用いた循環バッファとして実装されており、リスト (List<T>) の先頭要素を削除する場合と比較して、要素のシフトが発生しないため高いパフォーマンスを維持できます。

Queue<T>の基本操作

Queue<T> クラスを使いこなすためには、まず主要なメソッドを理解する必要があります。

最も頻繁に使用されるのは、要素を追加する Enqueue、要素を取り出す Dequeue、そして先頭の要素を覗き見る Peek の3つです。

要素の追加：Enqueue

キューの末尾に新しい要素を追加するには、Enqueue メソッドを使用します。

このメソッドを呼び出すたびに、キューのサイズは必要に応じて自動的に拡張されます。

要素の取り出しと削除：Dequeue

キューの先頭にある要素を取り出し、同時にその要素をキューから削除するには Dequeue メソッドを使用します。

もしキューが空の状態でこのメソッドを呼び出すと、InvalidOperationException がスローされるため、事前に要素が存在するかを確認するか、例外処理を適切に行う必要があります。

先頭要素の参照：Peek

キューから要素を削除せずに、次に取り出される予定の要素を確認したい場合は Peek メソッドを使用します。

これにより、処理を開始する前にデータの値をチェックすることが可能です。

基本操作のコード例

以下に、Queue<string> を使用した基本的な実装例を示します。

C#
using System;
using System.Collections.Generic;

class Program
{
    static void Main()
    {
        // キューのインスタンス化
        Queue<string> messageQueue = new Queue<string>();

        // 要素の追加 (Enqueue)
        messageQueue.Enqueue("第1メッセージ");
        messageQueue.Enqueue("第2メッセージ");
        messageQueue.Enqueue("第3メッセージ");

        Console.WriteLine($"現在のキューの数: {messageQueue.Count}");

        // 先頭の要素を確認 (Peek)
        string nextMessage = messageQueue.Peek();
        Console.WriteLine($"次回の処理対象: {nextMessage}");

        // 要素の取り出しと削除 (Dequeue)
        while (messageQueue.Count > 0)
        {
            string current = messageQueue.Dequeue();
            Console.WriteLine($"処理中: {current}");
        }

        Console.WriteLine($"処理後のキューの数: {messageQueue.Count}");
    }
}
実行結果
現在のキューの数: 3
次回の処理対象: 第1メッセージ
処理中: 第1メッセージ
処理中: 第2メッセージ
処理中: 第3メッセージ
処理後のキューの数: 0

Queue<T>の高度な操作とプロパティ

基本的な追加・削除以外にも、Queue<T> には効率的な開発をサポートするメソッドがいくつか用意されています。

キューの状態を確認する

Count プロパティ を使用することで、現在キュー内に保持されている要素の数を取得できます。

これはループの終了条件や、キューが空かどうかの判定に頻繁に利用されます。

また、特定の要素が含まれているかどうかを確認する Contains メソッドも存在します。

ただし、Contains メソッドの計算量は O(n) であるため、要素数が多い場合に頻繁に呼び出すとパフォーマンス低下の原因となる点に注意してください。

全要素のクリアと配列への変換

キュー内のすべての要素を一度に削除したい場合は Clear メソッドを使用します。

また、現在のキューの状態をスナップショットとして保存したり、他のメソッドへ渡したりするために ToArray メソッドで配列に変換することも可能です。

メモリの最適化：TrimExcess

Queue<T> は内部的に配列を確保していますが、大量の要素を処理した後にキューが小さくなった場合、未使用のメモリ領域が残ることがあります。

TrimExcess メソッドを呼び出すことで、内部配列のサイズを現在の要素数に合わせて縮小し、メモリ使用量を節約することができます。

内部実装とパフォーマンスの理解

C#の Queue<T> の挙動を深く理解するためには、その内部構造を知ることが重要です。

このクラスは内部的に 「循環バッファ (Circular Buffer)」 という仕組みを利用しています。

通常、配列の先頭要素を削除すると、後続のすべての要素を一つずつ前にずらす（シフトする）必要があります。

しかし、循環バッファでは「先頭（Head）」と「末尾（Tail）」を指すインデックスを動かすだけで削除・追加を完結させます。

そのため、Enqueue と Dequeue の時間計算量は O(1) となり、非常に高速です。

ただし、内部配列の容量が不足した際には、新しい大きな配列を確保して全要素をコピーする処理が発生します。

この際の計算量は O(n) となります。

あらかじめ扱うデータ数が予測できる場合は、コンストラクタで初期容量 (Capacity) を指定することで、この再確保によるオーバーヘッドを回避できます。

C#
// 初期容量を100に設定してインスタンス化
Queue<int> myQueue = new Queue<int>(100);

マルチスレッド環境におけるスレッドセーフな実装

標準の System.Collections.Generic.Queue<T> は、スレッドセーフではありません。

複数のスレッドから同時に Enqueue や Dequeue を行うと、内部データの不整合が発生し、予期せぬ例外やデータの破損を招く恐れがあります。

かつての .NET では、lock 文を用いて手動で同期制御を行っていましたが、現在の C# ではより洗練された方法が提供されています。

ConcurrentQueue<T> の利用

マルチスレッド環境での利用が想定される場合は、System.Collections.Concurrent 名前空間にある ConcurrentQueue<T> を使用するのが最適解です。

このクラスはロックフリーなアルゴリズムを用いて設計されており、高い並行性能を維持しつつ安全な操作を保証します。

ConcurrentQueue<T> では、メソッド体系が少し異なります。

  • 要素の追加： Enqueue
  • 要素の取り出し： TryDequeue
  • 要素の参照： TryPeek

TryDequeue は、キューが空であれば false を返し、要素が存在すれば out パラメータに値をセットして true を返します。

これにより、例外を発生させずに安全に値を取得できます。

ConcurrentQueue<T> の実装例

C#
using System;
using System.Collections.Concurrent;
using System.Threading.Tasks;

class ThreadSafeExample
{
    static async Task Main()
    {
        ConcurrentQueue<int> cq = new ConcurrentQueue<int>();

        // 並列でデータを投入
        Task producer = Task.Run(() =>
        {
            for (int i = 0; i < 10; i++)
            {
                cq.Enqueue(i);
                Console.WriteLine($"生産: {i}");
            }
        });

        // 並列でデータを消費
        Task consumer = Task.Run(() =>
        {
            int count = 0;
            while (count < 10)
            {
                if (cq.TryDequeue(out int result))
                {
                    Console.WriteLine($"消費: {result}");
                    count++;
                }
            }
        });

        await Task.WhenAll(producer, consumer);
        Console.WriteLine("全タスク完了");
    }
}

実行結果（順序は非決定的）:

生産: 0
生産: 1
消費: 0
生産: 2
消費: 1
... (省略) ...
全タスク完了

このように、並列処理を行うモダンなアプリケーション開発においては、ConcurrentQueue<T> を選択することが定石となっています。

Queue<T> と Stack<T> の使い分け

キューとよく対比されるデータ構造に Stack<T>（スタック）があります。

スタックは「後入れ先出し (LIFO: Last-In, First-Out)」の構造を持っており、最後に追加した要素が最初に取り出されます。

特徴Queue<T>Stack<T>
構造FIFO (先入れ先出し)LIFO (後入れ先出し)
追加メソッドEnqueuePush
削除メソッドDequeuePop
主な用途タスクスケジュール、印刷ジョブ、BFSブラウザの戻る機能、再帰の非再帰化、DFS

どちらを使用すべきかは、データの「順序」をどう扱いたいかに依存します。

時系列に従って古いものから処理したい場合は Queue<T> を、直近のアクションを優先したい場合は Stack<T> を選択してください。

Queue<T> を活用した実践的なシナリオ

ここでは、実際の開発現場で Queue<T> がどのように活用されているか、具体的なユースケースを挙げて解説します。

1. 非同期タスクのバッファリング

Webサーバーなどで大量のリクエストを受け取る際、すべてのリクエストを即座に重い処理（DB書き込みなど）に回すとシステムがパンクしてしまいます。

このような場合、リクエストを一旦キューに格納し、バックグラウンドのスレッドが一定のペースでキューから取り出して処理を継続させるというパターンが一般的です。

2. 幅優先探索 (BFS) の実装

グラフ理論や木構造の探索において、特定のノードから近い順に探索を行う「幅優先探索」を実現するためには、キューが必須となります。

現在のノードに隣接するノードをすべてキューに入れ、順番に取り出すことで、階層ごとの探索が可能になります。

3. ロギングシステム

アプリケーションの実行ログをファイルやデータベースに書き込む際、書き込み処理は I/O 負荷が高いためメインスレッドをブロックしたくありません。

ログメッセージをキューに高速に投げ込み、専用のライター thread がキューを監視して非同期に書き出す仕組みを構築することで、アプリケーションの応答性を維持できます。

パフォーマンスを最大化するためのベストプラクティス

Queue<T> をより効果的に利用するためのテクニックをいくつか紹介します。

初期容量の適切な設定

数千〜数万単位の要素を扱うと分かっている場合は、コンストラクタで capacity を指定しておくとよいです。

これにより内部配列の再確保回数が減り、メモリコピーや再割り当てによるオーバーヘッドが減少して実行速度が向上します。

要素の存在確認

要素を取り出す前には必ず Count > 0 を確認してください。

副作用を避けたい場合やより安全に扱いたい場合は、C# 8.0 以降で利用可能な TryPeek や TryDequeue を使うと、例外を発生させずに存在確認と取得ができます。

LINQの利用には慎重に

IEnumerable<T> を実装しているため LINQ でのフィルタや変換は可能ですが、キューは高速な順次処理が目的のデータ構造です。

頻繁に列挙（Enumerate）する必要があるなら、List<T> など列挙に適したデータ構造の採用を検討してください。

格納型の選択（struct と class）

小さな値型（struct）を格納すると参照型（class）よりメモリ効率が良くなる場合がありますが、サイズの大きな構造体はコピーコストが発生します。

用途や性能要件に応じて struct と class を適切に使い分けてください。

まとめ

C#の Queue<T> は、シンプルながらも非常に強力なコレクションクラスです。

FIFOの原則に基づき、データの追加と削除を O(1) という非常に低いコストで実現できるため、システムのパフォーマンスを支える基盤として多くの場面で採用されています。

基本的な使い方は非常に簡単ですが、内部の循環バッファの仕組みやメモリ管理、そしてマルチスレッド環境における ConcurrentQueue<T> の重要性を理解しておくことで、より堅牢で効率的なアプリケーションを構築できるようになります。

まずは標準的な Queue<T> でデータの流れを制御する方法をマスターし、要件に応じて初期容量の最適化やスレッドセーフな実装へとステップアップしていきましょう。

適切なデータ構造の選択は、保守性の高い高品質なコードを書くための第一歩です。