MENU

WinFormsでリングバッファを常時稼働させる実装と設計：CancellationTokenとProducer-Consumerのベストプラクティス

C#

WinFormsでセンサーやストリーミング処理を組むと「アプリ終了までリングバッファを止めずに回し続けたい」という要件に必ず出会います。本記事は、CircularBufferを汎用化しつつ、Producer/Consumerをフォーム側のTaskで駆動し、満杯・空ポリシーやキャンセル設計まで含めて“落ちない・止まらない”運用を実現するための実装・設計指針を凝縮して解説します。

目次

全体像：WinFormsでリングバッファを常時稼働させる設計

下図のようにデータ構造（CircularBuffer<T>）と非同期ループ（Producer/Consumer）を分離するのが基本方針です。バッファはスレッドセーフな最小機能（Enqueue/Dequeue/Peek）に徹し、待機やキャンセル、上書きなどの“ふるまい”は外側で制御します。

  • CircularBuffer<T>：純粋なコレクション。ジェネリックで型を統一。
  • AsyncCircularBuffer<T>：必要なら薄いラッパーを用意し、Full/Empty時のポリシーやCancellationTokenを扱う。
  • Producer/Consumer：フォーム起動時にTask.Runで開始し、FormClosingでCancelして停止。
  • UI更新：必ずInvoke/BeginInvokeでメインスレッドへ。

よくある課題と解決の要点

ジェネリック型を正しく統一

CircularBuffer<T>で汎用化し、Add(T)/Remove()/Peek()をすべて同一のTで運用します。途中でint固定の実装が混ざると再利用性とテスト性が急落します。

データ構造と非同期ルーチンを分離

リングバッファ自体は待機やキャンセルを持たないほうが保守しやすく、テストも簡単です。非同期はフォーム（またはサービス）側のTaskで制御します。必要に応じて非同期向け薄ラッパ（後述）を用意します。

読み出しは「削除」より「ピーク（Peek）」を用意

「書き込みが速く、読み出しが遅い」場面では、Peek()（取り出しても削除しない）を利用すると。最新データを追従しやすく、データロスを抑えられます。

満杯・空状態のポリシーを明示

実運用では「満杯時に上書きする（最新優先）」か「待機してでも欠損ゼロにする」かの判断が命です。下の表で目的別に選択してください。

状態選択肢メリットデメリット向いている用途
満杯（Writer）上書き（Latest Wins）遅延が伸びない／常に最新を保持古いデータは失われる波形・センサーのリアルタイム可視化、GUIプレビュー
満杯（Writer）待機（Lossless）欠損ゼロProducerがブロック、遅延増大ロギング、監査、ファイル出力、機械学習の収集
空（Reader）default(T)返却Consumerを止めない空読みの扱いが必要描画ループ、高fpsで回したい処理
空（Reader）待機（Lossless）CPU効率◎/データ欠損なし待ちが発生、UIと併用時は注意順次処理/ファイル出力/集計

CancellationTokenを双方向に

Producer/ConsumerのどちらのループもCancellationTokenを受け取り、FormClosing等でcts.Cancel()を呼ぶだけで即時停止できる構造にします。停止が速いほど「アプリが閉じない」事故を防げます。

代替案：BlockingCollection

BlockingCollection<T>は標準でスレッドセーフかつ待機制御まで揃っており、リング（固定長）のように使えます。上書き（Latest Wins）まではないため、必要なら「満杯時は古い要素を捨てる」処理を加えます（後述）。

容量設計：サイズをどう決めるか

基本式はシンプルです。

容量 ≒ 最大書込レート（item/秒） × 許容遅延（秒）

さらに「通常運転で占有率50%未満」を目標に余裕を持たせると、スパイク耐性が上がります。

項目例解説
最大書込レート2,000 item/s計測or見積り。センサー/ネット/デコーダの出力最大値
許容遅延0.25 sUI遅延/UX要件/規格値から逆算
必要容量500 item2,000 × 0.25 = 500
安全係数×2スパイク対策・季節変動・他処理との干渉
最終容量1,0242の冪に丸めるとmod演算で高速化しやすい

スレッドセーフな最小実装：CircularBuffer<T>

まずは純粋コレクションとしてのリングを実装します。Try系（非ブロッキング）のみを持ち、満杯でTryEnqueueが失敗、空でTryDequeue/Peekが失敗する最小形です。

using System;

namespace App.Buffers
{
public sealed class CircularBuffer
{
private readonly T[] _buffer;
private int _head; // 次に書く位置
private int _tail; // 次に読む位置
private int _count;
private readonly object _gate = new();
    public CircularBuffer(int capacity)
    {
        if (capacity &lt;= 0) throw new ArgumentOutOfRangeException(nameof(capacity));
        _buffer = new T[capacity];
    }

    public int Capacity =&gt; _buffer.Length;

    public int Count
    {
        get { lock (_gate) return _count; }
    }

    public bool IsFull
    {
        get { lock (_gate) return _count == _buffer.Length; }
    }

    public bool IsEmpty
    {
        get { lock (_gate) return _count == 0; }
    }

    public bool TryEnqueue(T item)
    {
        lock (_gate)
        {
            if (_count == _buffer.Length) return false;
            _buffer[_head] = item;
            _head = (_head + 1) % _buffer.Length;
            _count++;
            return true;
        }
    }

    // 満杯でも古いデータを捨てて必ず書く（Latest Wins）
    public void EnqueueOverwrite(T item, out bool overwritten)
    {
        lock (_gate)
        {
            if (_count == _buffer.Length)
            {
                _tail = (_tail + 1) % _buffer.Length; // 最古を捨てる
                overwritten = true;
            }
            else
            {
                _count++;
                overwritten = false;
            }
            _buffer[_head] = item;
            _head = (_head + 1) % _buffer.Length;
        }
    }

    public bool TryDequeue(out T item)
    {
        lock (_gate)
        {
            if (_count == 0)
            {
                item = default!;
                return false;
            }
            item = _buffer[_tail];
            _tail = (_tail + 1) % _buffer.Length;
            _count--;
            return true;
        }
    }

    public bool TryPeek(out T item)
    {
        lock (_gate)
        {
            if (_count == 0)
            {
                item = default!;
                return false;
            }
            item = _buffer[_tail];
            return true;
        }
    }
}

}

ここでは待機もキャンセルも持ちません。これにより、ユニットテストが非常に容易になります。

待機・キャンセル・ポリシーを担う薄ラッパ：AsyncCircularBuffer

満杯/空時の待機やCancellationTokenはラッパで扱うのが現実的です。SemaphoreSlimを用い、カウントを正しく保ちながら待機・上書きの両方を成立させます。

using System;
using System.Threading;
using System.Threading.Tasks;

namespace App.Buffers
{
public enum FullBehavior { Overwrite, Wait }
public enum EmptyBehavior { ReturnDefault, Wait }
public sealed class AsyncCircularBuffer&lt;T&gt; : IDisposable
{
    private readonly CircularBuffer&lt;T&gt; _core;
    private readonly SemaphoreSlim _items;  // 入っている要素数
    private readonly SemaphoreSlim _spaces; // 空き数
    private long _dropped;
    public FullBehavior FullPolicy { get; }
    public EmptyBehavior EmptyPolicy { get; }

    public AsyncCircularBuffer(int capacity, FullBehavior full = FullBehavior.Overwrite,
        EmptyBehavior empty = EmptyBehavior.Wait)
    {
        _core = new CircularBuffer&lt;T&gt;(capacity);
        _items = new SemaphoreSlim(0, capacity);
        _spaces = new SemaphoreSlim(capacity, capacity);
        FullPolicy = full;
        EmptyPolicy = empty;
    }

    public int Capacity =&gt; _core.Capacity;
    public int Count =&gt; _core.Count;
    public long DroppedCount =&gt; Interlocked.Read(ref _dropped);

    // 満杯時の挙動をポリシーで切り替え
    public async ValueTask AddAsync(T item, CancellationToken ct = default)
    {
        if (FullPolicy == FullBehavior.Wait)
        {
            await _spaces.WaitAsync(ct).ConfigureAwait(false);
            var ok = _core.TryEnqueue(item);
            if (!ok)
            {
                // 理論上起きないが、整合性のためフォールバック
                _core.EnqueueOverwrite(item, out _);
            }
            _items.Release();
        }
        else
        {
            _core.EnqueueOverwrite(item, out bool overwritten);
            if (overwritten) Interlocked.Increment(ref _dropped);
            // 上書きしなかった＝新規に1要素増えたのでカウンタを調整
            if (!overwritten)
            {
                _items.Release();   // itemが増えた
                _ = _spaces.Wait(0); // 空きが減った
            }
        }
    }

    // 空時の挙動をポリシーで切り替え
    public async ValueTask&lt;T&gt; RemoveAsync(CancellationToken ct = default)
    {
        if (EmptyPolicy == EmptyBehavior.Wait)
        {
            await _items.WaitAsync(ct).ConfigureAwait(false);
            if (_core.TryDequeue(out var item))
            {
                _spaces.Release();
                return item!;
            }
            // 万一失敗したらカウンタを戻す
            _items.Release();
            return default!;
        }
        else
        {
            if (_core.TryDequeue(out var item))
            {
                _spaces.Release();
                return item!;
            }
            return default!;
        }
    }

    // 読み出しても削除しない
    public async ValueTask&lt;T&gt; PeekAsync(CancellationToken ct = default)
    {
        if (EmptyPolicy == EmptyBehavior.Wait)
        {
            await _items.WaitAsync(ct).ConfigureAwait(false); // 1つ確保
            T item;
            if (_core.TryPeek(out item!))
            {
                _items.Release(); // 戻す（削除しないため）
                return item!;
            }
            _items.Release();
            return default!;
        }
        else
        {
            _core.TryPeek(out var item);
            return item!;
        }
    }

    public void Dispose()
    {
        _items.Dispose();
        _spaces.Dispose();
    }
}

}

このラッパにより、上書き（Latest Wins）/待機（Lossless）を呼び出し側から選べます。さらに、DroppedCountで上書き件数を可視化でき、ボトルネック解析に役立ちます。

WinFormsへの組み込みサンプル

フォーム起動時にProducer/Consumerを開始し、フォームが閉じるときにキャンセルして止めます。UI更新はBeginInvokeでメインスレッドに戻します。

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;
using App.Buffers;

public partial class MainForm : Form
{
private readonly AsyncCircularBuffer _buffer;
private readonly CancellationTokenSource _cts = new();
private Task? _producerTask;
private Task? _consumerTask;
public MainForm()
{
    InitializeComponent();

    // ポリシー例：Writerは上書き、Readerは待機
    _buffer = new AsyncCircularBuffer&lt;byte[]&gt;(
        capacity: 1024, 
        full: FullBehavior.Overwrite, 
        empty: EmptyBehavior.Wait);

    // 起動と同時に稼働
    _producerTask = Task.Run(() =&gt; ProducerLoopAsync(_cts.Token));
    _consumerTask = Task.Run(() =&gt; ConsumerLoopAsync(_cts.Token));
}

protected override void OnFormClosing(FormClosingEventArgs e)
{
    // すべてのループに停止指示
    _cts.Cancel();
    base.OnFormClosing(e);
}

protected override async void OnFormClosed(FormClosedEventArgs e)
{
    try { if (_producerTask != null) await _producerTask; } catch { /* ignore */ }
    try { if (_consumerTask != null) await _consumerTask; } catch { /* ignore */ }
    _buffer.Dispose();
    base.OnFormClosed(e);
}

private async Task ProducerLoopAsync(CancellationToken ct)
{
    var rnd = new Random();
    while (!ct.IsCancellationRequested)
    {
        // ダミーデータを生成（実運用ではセンサーやソケット受信など）
        var frame = new byte[256];
        rnd.NextBytes(frame);

        await _buffer.AddAsync(frame, ct).ConfigureAwait(false);

        // サンプル：1ms周期。実運用では実データ到着間隔に合わせる
        await Task.Delay(1, ct).ConfigureAwait(false);
    }
}

private async Task ConsumerLoopAsync(CancellationToken ct)
{
    while (!ct.IsCancellationRequested)
    {
        // 最新を見たいだけなら PeekAsync でもよい
        var frame = await _buffer.RemoveAsync(ct).ConfigureAwait(false);
        if (frame is null || frame.Length == 0) continue;

        // UI更新はメインスレッドへ
        BeginInvoke((Action)(() =&gt;
        {
            // 例：バッファ状態をラベルに表示
            labelCount.Text = $&quot;Count={_buffer.Count} / Dropped={_buffer.DroppedCount}&quot;;
        }));

        // 実処理：エンコード/保存/描画等
        // ...
    }
}

}
  • フォームの終了はCancelのみで完了できるよう、ループはCancellationTokenに必ず応答するコードにします。
  • UIスレッドを詰まらせる.Wait()や.Resultは禁止。常にawait。

読み出し戦略：Remove派とPeek派

用途で最適解が変わります。描画系など「最新だけ見られればよい」場合はPeekAsyncで観測し続け、処理に使い終えたタイミングで余裕があればRemoveAsyncで古いものをまとめて捨てるのも有効です。

戦略効果向いている場面注意点
Removeのみ逐次処理・厳密な順序保証ファイル書出し、バッチ処理、集計Consumerが詰まると遅延が増える
Peek中心＋適宜Remove最新追従・低遅延グラフ描画、UIプレビュー、アラート監視未処理データの扱い設計が必要

運用監視：落ちる前に気付く指標

  • 占有率：Count / Capacityが50%を常時超えるならボトルネックが発生。
  • DroppedCount：上書き件数。1秒あたりの増分が増えたらConsumer強化や容量見直し。
  • Producer/Consumerレート：1秒あたりAdd/Remove数。差分が遅延の源。
  • UIフレーム時間：描画に時間がかかると空読みや遅延が発生。

以下の簡易メトリクスで可視化できます。

volatile int _addPerSec, _remPerSec;
var addWatch = System.Diagnostics.Stopwatch.StartNew();
var remWatch = System.Diagnostics.Stopwatch.StartNew();
// AddAsync/RemoveAsync成功時にインクリメントし、1秒ごとにラベル更新など

パフォーマンス実践Tips

  • 配列の再利用：ArrayPool<byte>.Sharedで大きな配列をプールし、GC負荷を抑える。
  • 2の冪容量：モジュロ計算がビット演算に最適化しやすく高速。
  • 例外を制御フローにしない：満杯/空は例外でなくTry*で扱う。
  • ConfigureAwait(false)：バックグラウンドTaskでは文脈復元を避ける。
  • 短い粒度の待機：Task.Delay(1)など過度なスピンを避ける。

BlockingCollectionで代替する（簡単・堅牢）

リング“的”に使うなら以下。満杯時は待機、または古い要素を捨てつつ追加（擬似Latest Wins）。

using System.Collections.Concurrent;

// 待機（Lossless）
var bc = new BlockingCollection(boundedCapacity: 1024);
// Producer
bc.Add(frame, ct);
// Consumer
var item = bc.Take(ct);

// 最新優先（擬似Latest Wins）
var bc2 = new BlockingCollection(boundedCapacity: 1024);
bool added = bc2.TryAdd(frame);
if (!added)
{
// 最古を捨ててから試す
bc2.TryTake(out _);       // 1つ捨てる
bc2.TryAdd(frame);
}

標準のみで完結し、テストも容易。Peekが要らず順序が重要なら有力な選択です。

障害パターンと対策チェックリスト

  • フォーム終了時にアプリが固まる → すべてのループがCancellationTokenを尊重しているか。.Wait()や.Resultの混入を除去。
  • ドロップが止まらない → 容量を増やす、Consumerの並列化、処理の間引き、描画レート制御。
  • UIがカクつく → 重い処理をUIスレッドで実行していないか。BeginInvokeで最小限の更新に限定。
  • メモリ使用量が増え続ける → 大きな配列の使い捨て、ArrayPool未使用、参照を保持し続けている。
  • 複数Consumerで取り合い → 1:1を守るか、ブロードキャストは別の仕組み（Channelを複数用意、Pub/Sub）に分離。

実運用に効く微テク

  • バースト吸収のための一時的増量：メンテ画面から容量を動的に上げ下げできるようにしておく（設定→再生成）。
  • 遅延の上限ガード：Consumer側の時間計測で、遅延が上限を超えたら上書きモードへ一時移行。
  • データの世代番号付与：Producerでlong seqを採番し、Consumer側で欠損や順序入替を検知。
  • ダンプ機能：異常時にバッファ内内容をファイルへダンプして再現性を確保。

まとめ：止めずに回すためのコア原則

  • ジェネリックで統一し、データ構造は最小・純粋に。
  • Producer/ConsumerはTaskで起動、UI更新は必ずメインスレッドへ。
  • 満杯・空ポリシーを明示して切替可能に。
  • キャンセルは双方向。
  • 容量＝最大レート×許容遅延、占有率50%以下を狙う。

これらを押さえれば、WinFormsでもリングバッファを安全に「常時回し」つつ、遅延・欠損・停止のトラブルを最小化できます。

付録：完全版サンプル（バッファ＋フォーム）

上記の部品を1つのプロジェクトで動く構成にまとめた例です。実データ部分を差し替えれば、そのまま運用の足場になります。

// Program.cs
using System;
using System.Windows.Forms;

internal static class Program
{
[STAThread]
static void Main()
{
Application.SetHighDpiMode(HighDpiMode.SystemAware);
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
Application.Run(new MainForm());
}
}

// MainForm.cs（前掲のものにラベル等のUIパーツを追加）

現場ではこれにメトリクス表示（占有率ゲージ、ドロップ数、レート）を加えると運用時の安心度が段違いに上がります。

クイックリファレンス

項目推奨理由
型CircularBuffer<T>再利用性・テスト容易性
満杯時上書き or 待機（選択式）UX/堅牢性の要件で使い分け
空時default(T)返却 or 待機UIループと相性を取る
キャンセル双方向（Producer/Consumer）終了の安定性
容量最大レート×許容遅延 × 安全係数スパイク耐性
UI更新Invoke/BeginInvokeスレッド境界の厳守
C#
C# CancellationToken WinForms Producer-Consumer リングバッファ BlockingCollection

この記事を書いた人

佐藤健司のアバター 佐藤健司

実務の現場で詰まりがちなポイントを地図にするITブログ「IT trip」を運営。Windows／Office（Teams・Excel）からSQL、サーバ運用、ガジェットまで、再現性のある手順と“なぜそうなるか”を丁寧に解説します。読んだらすぐ試せること、そして迷った人の次の一歩が見えることを大切にしています。

関連記事

コメント

コメントする

目次