Question

我想出了一些代码来消耗队列中所有的wating项目。而不是逐项处理项目，将所有等待的项目作为一组进行处理是有意义的。

我已经宣布了我的队列。

private BlockingCollection<Item> items = 
    new BlockingCollection<Item>(new ConcurrentQueue<Item>);

然后，在消费者线程上，我打算分批阅读这些项目，

Item nextItem;
while (this.items.TryTake(out nextItem, -1))
{
    var workToDo = new List<Item>();
    workToDo.Add(nextItem);

    while(this.items.TryTake(out nextItem))
    {
        workToDo.Add(nextItem);
    }

    // process workToDo, then go back to the queue.
}

这种方法缺乏GetConsumingEnumerable的实用性，我不禁想知道我是否错过了更好的方法，或者我的方法是否存在缺陷。

是否有更好的方法可以批量使用BlockingCollection<T>？

Answer 1

一种解决方案是使用BufferBlock<T> System.Threading.Tasks.Dataflow（包含在.net core 3+中）。它不使用GetConsumingEnumerable()，但仍然允许您使用相同的实用程序，主要是：

允许具有多个（对称和/或非对称）消费者和生产者的并行处理
线程安全（允许上述操作）-无需担心竞争条件
可以通过取消令牌和/或收集完成来取消
消费者会一直阻塞，直到有可用数据为止，避免在轮询时浪费CPU周期

还有一个BatchBlock<T>，但这将您限制为固定大小的批次。

var buffer = new BufferBlock<Item>();
while (await buffer.OutputAvailableAsync())
{
    if (buffer.TryReceiveAll(out var items))
        //process items
}

这是一个工作示例，演示了以下内容：

多个对称的使用者，可并行处理可变长度的批次
多个对称生成器（在此示例中并非真正并行运行）
制作人完成后可以完成收藏的能力
为了使示例简短，我没有演示使用CancellationToken
等待生产者和/或消费者完成的能力
能够从不允许异步的区域（例如构造函数）进行调用
不需要Thread.Sleep()调用，但可以帮助模拟一些在更繁重的情况下可能发生的处理时间
Task.WaitAll()和Thread.Sleep()都可以选择转换为它们的异步等效物
无需使用任何外部库

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;

static class Program
{
    static void Main()
    {
        var buffer = new BufferBlock<string>();

        // Kick off consumer task(s)
        List<Task> consumers = new List<Task>();
        for (int i = 0; i < 3; i++)
        {
            consumers.Add(Task.Factory.StartNew(async () =>
            {
                // need to copy this due to lambda variable capture
                var num = i; 
                while (await buffer.OutputAvailableAsync())
                {
                    if (buffer.TryReceiveAll(out var items))
                        Console.WriteLine($"Consumer {num}:    " + 
                            items.Aggregate((a, b) => a + ", " + b));

                        // real life processing would take some time
                        await Task.Delay(500); 
                }

                Console.WriteLine($"Consumer {num} complete");
            }));

            // give consumer tasks time to activate for a better demo
            Thread.Sleep(100); 
        }

        // Kick off producer task(s)
        List<Task> producers = new List<Task>();
        for (int i = 0; i < 3; i++)
        {
            producers.Add(Task.Factory.StartNew(() =>
            {
                for (int j = 0 + (1000 * i); j < 500 + (1000 * i); j++)
                    buffer.Post(j.ToString());
            }));

            // space out the producers for a better demo
            Thread.Sleep(10); 
        }

        // may also use the async equivalent
        Task.WaitAll(producers.ToArray());
        Console.WriteLine("Finished waiting on producers");

        // demo being able to complete the collection
        buffer.Complete(); 

        // may also use the async equivalent
        Task.WaitAll(consumers.ToArray()); 
        Console.WriteLine("Finished waiting on consumers");

        Console.ReadLine();
    }
}

这是该代码的简化版本。

using System;
using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using System.Threading.Tasks.Dataflow;

class Program
{
    private static async Task Main()
    {
        var buffer = new BufferBlock<string>();

        // Kick off consumer task(s)
        var consumers = new List<Task>();
        for (var i = 0; i < 3; i++)
        {
            var id = i;
            consumers.Add(Task.Run(() => StartConsumer(id, buffer)));

            // give consumer tasks time to activate for a better demo
            await Task.Delay(100);
        }

        // Kick off producer task(s)
        var producers = new List<Task>();
        for (var i = 0; i < 3; i++)
        {
            var pid = i;
            producers.Add(Task.Run(() => StartProducer(pid, buffer)));

            // space out the producers for a better demo
            await Task.Delay(10);
        }

        // may also use the async equivalent
        await Task.WhenAll(producers);
        Console.WriteLine("Finished waiting on producers");

        // demo being able to complete the collection
        buffer.Complete();

        // may also use the async equivalent
        await Task.WhenAll(consumers);
        Console.WriteLine("Finished waiting on consumers");

        Console.ReadLine();
    }

    private static async Task StartConsumer(
            int id,
            IReceivableSourceBlock<string> buffer)
    {
        while (await buffer.OutputAvailableAsync())
        {
            if (buffer.TryReceiveAll(out var items))
            {
                Console.WriteLine($"Consumer {id}: " + 
                    items.Aggregate((a, b) => a + ", " + b));
            }

            // real life processing would take some time
            await Task.Delay(500);
        }

        Console.WriteLine($"Consumer {id} complete");
    }

    private static Task StartProducer(int pid, ITargetBlock<string> buffer)
    {
        for (var j = 0 + (1000 * pid); j < 500 + (1000 * pid); j++)
        {
            buffer.Post(j.ToString());
        }

        return Task.CompletedTask;
    }
}

Answer 2

虽然在某些方面不如ConcurrentQueue<T>好，但我自己的LLQueue<T>允许使用AtomicDequeueAll方法进行批量出列，其中队列中当前所有项目都是从单个（原子和线程安全）操作，然后在非线程安全集合中供单个线程使用。此方法专为您要批量读取操作的方案而设计。

但这并没有阻止，尽管它可以用来轻松地创建阻塞集合：

public BlockingBatchedQueue<T>
{
  private readonly AutoResetEvent _are = new AutoResetEvent(false);
  private readonly LLQueue<T> _store;
  public void Add(T item)
  {
    _store.Enqueue(item);
    _are.Set();
  }
  public IEnumerable<T> Take()
  {
    _are.WaitOne();
    return _store.AtomicDequeueAll();
  }
  public bool TryTake(out IEnumerable<T> items, int millisecTimeout)
  {
    if(_are.WaitOne(millisecTimeout))
    {
      items = _store.AtomicDequeueAll();
      return true;
    }
    items = null;
    return false;
  }
}

这是一个不做以下事情的起点：

处理待处理的等待读者。
担心一个潜在的竞赛，多个读者都是在一个人正在阅读时发生的一次写入触发（它只是考虑偶尔空的结果可以说是好的）。
在写作上放置任何上限。

所有这些都可以添加，但我希望保持最低限度的实际用途，希望在上面定义的限制范围内没有错误。

如何批量使用BlockingCollection <t> </t>

2 个答案: