Question

我希望有一种队列，其中一个源在其中输入数据，另一侧将有消费者等待，当他们检测到队列不为空时将开始执行数据，直到它们停止。但重要的是，如果队列被清空，他们仍将继续观察队列，这样如果有更多的数据弹出，他们将能够消耗它。我发现由multiple consumer and multiple producers作为消费者嵌套在生产者中，在我的情况下，我无法做到这一点，因为我将有一个单一的来源和消费者致力于队列，直到我阻止他们。因此，不是连续的，而是消费者和生产者并行执行。

将通过

并行消费者和生产者

Parallel.Invoke(() => producer(), () => consumers());

问题是我将如何执行队列的内容，该队列有时是空的

Answer 1

您可以使用BlockingCollection<T>相对轻松地解决此问题。

您可以将其中一个用作队列，并将其引用传递给producer()和每个consumers()。

您将从每个消费者线程中调用GetConsumingEnumerable()，并将其与foreach一起使用。

生产者线程会将项目添加到集合中，并在生成完成后调用CompleteAdding()。这将自动使所有消费者线程退出其foreach循环。

这是一个基本示例（没有错误处理）。对Thread.Sleep()的调用是模拟加载，不应在实际代码中使用。

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

namespace Demo
{
    internal class Program
    {
        private static void Main(string[] args)
        {
            ThreadPool.SetMinThreads(10, 0); // To help the demo; not needed in real code.
            var plant = new ProcessingPlant();
            plant.Process();
            Console.WriteLine("Work complete.");
        }
    }

    public sealed class ProcessingPlant
    {
        private readonly BlockingCollection<string> _queue = new BlockingCollection<string>();

        public void Process()
        {
            Parallel.Invoke(producer, consumers);
        }

        private void producer()
        {
            for (int i = 0; i < 100; ++i)
            {
                string item = i.ToString();
                Console.WriteLine("Producer is queueing {0}", item);
               _queue.Add(item);  // <- Here's where we add an item to the queue.
                Thread.Sleep(0);
            }

            _queue.CompleteAdding(); // <- Here's where we make all the consumers
        }                            //    exit their foreach loops.

        private void consumers()
        {
            Parallel.Invoke(
                () => consumer(1),
                () => consumer(2),
                () => consumer(3),
                () => consumer(4),
                () => consumer(5)
            );
        }

        private void consumer(int id)
        {
            Console.WriteLine("Consumer {0} is starting.", id);

            foreach (var item in _queue.GetConsumingEnumerable()) // <- Here's where we remove items.
            {
                Console.WriteLine("Consumer {0} read {1}", id, item);
                Thread.Sleep(0);
            }

            Console.WriteLine("Consumer {0} is stopping.", id);
        }
    }
}

（我知道这只是为了启动消费者而使用额外的线程，但我这样做是为了避免模糊真实点 - 这是为了演示使用BlockingCollection。）

单个源生产者与多个并行工作的消费者

1 个答案: