【C#】以 BlockingCollection 为核心的多相机 YOLO 检测任务处理框架 - 指南

以 BlockingCollection 为核心的多相机 YOLO 检测任务处理框架

在工业视觉应用中，我们经常会遇到一台电脑同时接入多台相机的场景。比如 10 台相机同时拍摄生产线上的产品，通过硬件 IO 触发采图，然后进行 YOLO 缺陷检测。

如果不合理设计，容易出现以下挑战：

• 回调线程阻塞导致相机触发丢帧
• 多线程抢占 YOLO 对象导致检测结果错乱
• 图像内存泄露或 UI 更新异常

本文将以 BlockingCollection 为核心，介绍一个线程安全、支持多相机任务队列的 YOLO 检测框架。

---

1. 为什么选择 BlockingCollection

BlockingCollection<T> 是 .NET 提供的一个 线程安全的生产者-消费者队列，非常适合处理相机采图任务。

优点：

• 线程安全：多个线程同时 Add/Take 没问题
• 阻塞消费：队列为空时，Take 或 GetConsumingEnumerable 会自动等待
• 容量限制：防止队列无限增长
• 优雅结束：调用 CompleteAdding() 后，消费者循环可以自动退出

Tip：BlockingCollection 内部默认基于 ConcurrentQueue<T>，也可以替换为 ConcurrentStack<T> 或 ConcurrentBag<T>。

---

2. 相比 ConcurrentQueue / ConcurrentBag 的优势

特性	ConcurrentQueue	ConcurrentBag	BlockingCollection
顺序	FIFO	无序	FIFO / 自定义
阻塞	❌	❌	✅
容量限制	❌	❌	✅
支持生产者-消费者模式	❌	❌	✅ 内置
可结束队列/循环	❌	❌	✅ CompleteAdding

总结在 ConcurrentQueue/Bag 基础上加了阻塞、容量、结束控制，更适合多线程任务队列场景。就是：BlockingCollection 本质上

---

3. 多相机任务处理思路

针对 10 台相机 IO 触发的场景，设计思路如下：

1. Update 回调

   • 回调线程只做一件事：将 CameraInfo 入队
   • 避免在回调中执行耗时的检测任务，防止阻塞触发

2. 后台 WorkerLoop

   • 从 BlockingCollection 队列中取任务
   • 调用 Detection() 进行 YOLO 处理

3. Detection 处理逻辑

   • 图像预处理（Blob、裁剪、摆正等）
   • YOLO 推理（检测或分割）
   • UI 表明（通过 Dispatcher 确保线程安全）
   • 任务做完后释放图像内存

4. 停止 / 完整退出

   • 调用 CompleteAdding() 告诉消费者：以后不再有新任务
   • 消费者循环自动退出

---

4. 核心代码示例

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.Diagnostics;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Threading;
public class CameraProcessor
{
private BlockingCollection<CameraInfo> taskQueue;
  private CancellationTokenSource cts;
  private Task workerTask;
  private readonly Dispatcher uiDispatcher;
  public CameraProcessor(Dispatcher dispatcher)
  {
  uiDispatcher = dispatcher;
  StartWorker();
  }
  private void StartWorker()
  {
  taskQueue = new BlockingCollection<CameraInfo>();
    cts = new CancellationTokenSource();
    workerTask = Task.Run(() => WorkerLoop(), cts.Token);
    }
    public void Update(CameraInfo info) => taskQueue.Add(info);
    private void WorkerLoop()
    {
    foreach (var info in taskQueue.GetConsumingEnumerable(cts.Token))
    {
    try
    {
    var graphic = GetGraphicBySn(info.SerialNumber);
    if (graphic != null)
    {
    var results = Detection(graphic, info.Image);
    // UI 更新
    uiDispatcher.Invoke(() =>
    {
    graphic.StatusText = "检测完成";
    graphic.LastResults = results;
    });
    }
    info.Image?.Dispose(); // 避免内存泄漏
    }
    catch (Exception ex)
    {
    Debug.WriteLine($"检测异常: {ex}");
    }
    }
    }
    public void Stop()
    {
    taskQueue.CompleteAdding();
    cts.Cancel();
    workerTask.Wait();
    }
    public void Restart()
    {
    Stop();
    StartWorker();
    }
    private List<YOLOData> Detection(GraphicInfo graphic, HObject image)
      {
      Stopwatch sw = new Stopwatch();
      List<YOLOData> data = new List<YOLOData>();
        // 1. 预处理
        sw.Restart();
        HObject imgProduct = PreprocessImage(graphic, image);
        sw.Stop();
        long preprocessTime = sw.ElapsedMilliseconds;
        // 2. YOLO 推理
        sw.Restart();
        //推理~~~~~
        sw.Stop();
        long detectTime = sw.ElapsedMilliseconds;
        return data;
        }
        private HObject PreprocessImage(GraphicInfo graphic, HObject image)
        {
        HObject imgProduct = null;
        if (graphic.BlobConfig.BlobEnable)
        imageScriptTool.BlobProduct(image, graphic.BlobConfig, out imgProduct);
        if (graphic.ScriptConfig.Preprocessing)
        imageScriptTool.Preprocess(imgProduct ?? image, graphic.ScriptConfig.PreprocessFuncName, out imgProduct);
        if (imgProduct == null)
        imgProduct = image.Clone();
        if (graphic.ScriptConfig.定位摆正)
        imageScriptTool.PosJust(image, imgProduct, out imgProduct, out HTuple FixDeg, false);
        return imgProduct;
        }
        private GraphicInfo GetGraphicBySn(string sn)
        {
        // TODO: 根据相机序列号找到对应的 GraphicInfo
        return null;
        }
        }

---

5. 使用建议

1. 回调线程只入队
   避免直接在 IO 回调里做检测，防止阻塞相机触发。

2. 后台线程消费
   WorkerLoop 永远循环消费任务，保证线程安全。

3. UI 更新
   通过 Dispatcher.Invoke 确保 WPF 控件安全访问。

4. 停止 / 重启

   • 程序退出时调用 Stop() → 完成队列 → 优雅退出
   • 如果需要“暂停/恢复”，可用标志位控制，而不是 CompleteAdding() 再恢复。

5. 多相机独立 YOLO 实例
   每台相机维护独立的 YOLO 和预处理对象，避免线程竞争。

---

6. 总结

• BlockingCollection<T> 是多线程生产者-消费者模式的核心利器，适合高并发图像处理场景
• 将相机回调与耗时检测解耦，保证系统稳定
• 完整框架支持多相机并发检测、UI 安全更新、暂停/停止控制