生产者消费者模型

生产者消费者队列是一个很常见的任务调度执行模型，它的优点不仅是可以释放UI线程，让任务在平行的后台工作线程中进行，而且还可以对工作线程数做精准的控制。甚至可以动态的增加或减少工作线程数来达到效率和资源的平衡，被广泛的用于后台任务执行以及线程数据交互等。

 

生产者消费者模型一般有3个组成部分：

• 一个用于存放任务（数据）的队列。
• 一个将任务插入队列的方法。
• 一个或者更多个工作（消费）线程从队列中取出任务并执行。

以下是一个最基础的生产者消费者模型框架（此代码存在线程安全问题）

public class ProducerConsumerQueue
{
    //一个存放任务的队列
    private Queue<string> _queue;

    public ProducerConsumerQueue()
    {
        _queue = new Queue<string>();

        //一个工作线程启动执行队列中的任务
        new Thread(Consume).Start();
    }

    //一个插入队列的公共方法
    public void EnQueue(string task)
    {
        _queue.Enqueue(task);
    }

        //从队列中取任务执行
    private void Consume()
    {
        while (true)
        {
            //如果队列有数据，就从队列中取出数据，否则空循环
            if (_queue.Count > 0)
            {
                var task = _queue.Dequeue();
                if (task == null)
                {
                    Console.WriteLine(
                        string.Format("{0}:{1}:{2}", 
                        Thread.CurrentThread.ManagedThreadId, 
                        "Over", 
                        _queue.Count));
                    break;
                }
                Console.WriteLine(
                    string.Format("{0}:{1}", 
                    Thread.CurrentThread.ManagedThreadId, 
                    task));
            }
        }
    }
}

class Program
{
    static void Main(string[] args)
    {
        var queue = new ProducerConsumerQueue();

        for (int i = 0; i < 10; i++)
        {
            var temp = i;
            queue.EnQueue(temp + "");
        }

        Console.ReadLine();
    }
}

以上的代码很简单，甚至没有锁。只有一个线程负责向队列中插入数据，同时也只有一个线程负责从队列中取数据，那会不会存在安全隐患呢？我想很多人的一个误区是只有当两个或两个以上的生产者（消费者）同时操作队列的时候，才会出现线程同步的问题（因为同时存，或者同时取会产生覆盖或者取相同值的情况），如果只有一个线程存，一个线程取是不会有线程安全问题的。有这个误区是因为不了解队列的存取逻辑。简单的说，Queue队列是用数组实现的，如果Enqueue的时候发现数组的大小不够大，就会重新new数组，转移旧数据等。如果在这个过程中，取队列的线程取数据，就有可能发生dequeue返回为null的情况。

拿我们上面的例子来说：调用的时候只插入10个数据，假如这里把new queue改为赋值了默认为20的队列

_queue = new Queue<string>(); ==> _queue = new Queue<string>(20); //没有参数，默认的数组大小为4

那么，如果只有一个线程取，只有一个线程存，并且可以保证queue不会扩容的情况下，确实是不需要加锁去控制的。

 

但很显然，这种情况不通用，所以我们要修改上面的代码让其变得线程安全。并且希望当队列中没有数据的时候，取线程可以休息，而不是像现在这样一直空跑消耗资源。

public class ProducerConsumerQueue : IDisposable
{
    //一个存放任务的队列
    private Queue<string> _queue;
    private Thread _worker;
    private readonly object _locker = new object();
    private AutoResetEvent _resetEvent = new AutoResetEvent(false);

    public ProducerConsumerQueue()
    {
        _queue = new Queue<string>();
        _worker = new Thread(Consume);
        //一个工作线程启动执行队列中的任务
        _worker.Start();
    }

    //一个插入队列的公共方法
    public void EnQueue(string task)
    {
        lock (_locker)
        {
            _queue.Enqueue(task);
        }
        _resetEvent.Set();
    }

    //从队列中取任务执行
    private void Consume()
    {
        while (true)
        {
            string task = null;
            //如果队列有数据，就从队列中取出数据，否则空循环
            lock (_locker)
            {
                if (_queue.Count > 0)
                {
                    task = _queue.Dequeue();

                    if (string.Equals(task, "Over"))
                    {
                        return;
                    }
                }
            }
            
            if (task != null)
            {
                Console.WriteLine(
                    string.Format("{0}:{1}",
                        Thread.CurrentThread.ManagedThreadId,
                        task));
            }
            else
            {
                //队列中已经没有数据,等待信号。
                _resetEvent.WaitOne();
            }
        }
    }

    public void Dispose()
    {
        EnQueue("Over");
        //等待线程结束
        _worker.Join();
        //释放资源
        _resetEvent.Close();
    }
}

class Program
{
    static void Main(string[] args)
    {
        using (ProducerConsumerQueue q = new ProducerConsumerQueue())
        {
            q.EnQueue("Hello");
            for (int i = 0; i < 10; i++)
            {
                q.EnQueue(string.Format("Say {0}", i));

            }
            q.EnQueue("Goodbye!");
        }
        Console.ReadKey();
    }
}

这里加入了Dispose方法用来结束队列（插入“Over”）并且释放信号量资源。以上是一个基础且实用的生产消费模型。下面会根据需求的演变，我们来逐渐将其优化。

 

新需求：

1. 更多的消费者为我们工作。

Thread _worker => Thread[] _workers.

2. 队列中的任务变成更灵活的action，而不仅仅是个打印输出。

Queue<string> => Queue<Action>

3. 当队列中没有任务的时候，blocking。

public class PCQueue
{
    private Thread[] _workers;
    private Queue<Action> _queue = new Queue<Action>();
    readonly object _lock = new object();

    public PCQueue(int count)
    {
        _workers = new Thread[count];
        for (int i = 0; i < count; i++)
        {
            _workers[i] = new Thread(Consume);
            _workers[i].Start();
        }
    }

    public void EnQueueTask(Action action)
    {
        lock (_lock)
        {
            _queue.Enqueue(action);
            Monitor.Pulse(_lock);
        }
    }

    private void Consume()
    {           
        while (true)
        {
            Action action = null;
            lock (_lock)
            {
                while (_queue.Count==0)
                {
                    Monitor.Wait(_lock);//_lock is released
                    // _lock is regained
                }
                action = _queue.Dequeue();
            }
            if (action == null) return;
            action();
        }
    }

    public void Shutdown(bool waitForWorkers)
    {
        foreach (Thread worker in _workers)
        {
            EnQueueTask(null);
        }

        if (waitForWorkers)
        {
            foreach (Thread worker in _workers)
            {
                worker.Join();
            }
        }
    }
}

我们先来看一下队列中的Consume方法。首先判断队列中是否有要操作的数据（_queue.Count==0）如果没有，则等待Monitor.wait(_locker)。这里需要注意的是：根据Monitor的特性，虽然在lock(){}代码块中，当Monitor.wait(_locker)时，但是会block住(等待)并且释放_locker锁。这时生产者可以获得锁并且通过Pluse来改变block的条件。并让消费者通过While循环自己来判断是否应该继续执行。

主程序调用代码如下：

static void Main(string[] args)
{
    PCQueue q = new PCQueue(2);

    Console.WriteLine("Enqueueing 10 items...");

    for (int i = 0; i < 10; i++)
    {
        int itemNumber = i;
        q.EnQueueTask(()=> {
            Console.WriteLine(string.Format("{0} Say {1}", Thread.CurrentThread.ManagedThreadId, itemNumber));
            Thread.Sleep(100);
        });
    }

    q.EnQueueTask(()=> {
        Console.WriteLine("{0} Goodbey",Thread.CurrentThread.ManagedThreadId);
    });

    q.Shutdown(true);
    Console.ReadKey();
}

 

进阶需求：

• 想要知道一个任务现在执行的状态。
• 可以Cancel一个没有开始的任务。
• 可以处理任务执行中的异常。

引入例子之前，介绍一个接口IProducerConsumerCollection<T>和一个自带Block属性的集合BlockingCollection<T>

 

IProducerConsumerCollection<T>

从名字就可以看出，这个接口是用来定义生产者/消费者模型中使用的集合。正如前文介绍的：模型的3个要素之一就是任务队列。当然这里说是队列，其实就是任务存放的容器（Collection）。它可以是队列，也可以是堆栈，还可以是无序列表。这就需要看具体需求而定了。

以下的三个类已经实现了这个接口，并且是线程安全的。

ConcurrentStack<T> //堆栈，FIFO
ConcurrentQueue<T> //队列, FILO
ConcurrentBag<T> // No order

如果以上的三个类还不能满足你插入集合和出集合的顺序需求，你可以自己实现IProducerConsumerCollection接口来满足自定义的需求。

 

BlockingCollection<T>

从命名就可以知道，BlockingCollection是有Block的功能的。BlockingCollection可以包装一个IProducerConsumerCollection，并使其在容器没元素时或者超过容器最大值是Block。

默认的情况下（构造参数没有传参new BlockingCollection()）BlockingCollection会构建一个ConcurrentQueue。除了常规的Add方法之外，它拥有比较特别的取出元素和结束的方法。分别是

1. GetConsumingEnumerable //在foreach中使用

• 从集合中取出元素
• 如果结合空，Block住
• 当CompleteAdding被调用，则结束foreach遍历

2. CompleteAdding

阻止继续Enqueue集合。

 

有了以上的铺垫，我们来看看优化后的模型：

public class PCQueue : IDisposable
{
    public class WorkItem
    {
        public readonly TaskCompletionSource<object> TaskSource;
        public readonly Action Action;
        public readonly CancellationToken? CancelToken;

        public WorkItem(
          TaskCompletionSource<object> taskSource,
          Action action,
          CancellationToken? cancelToken)
        {
            TaskSource = taskSource;
            Action = action;
            CancelToken = cancelToken;
        }
    }

    BlockingCollection<WorkItem> _taskQ = null;

    public PCQueue(int workerCount)
    {
        _taskQ = new BlockingCollection<WorkItem>();
        // Create and start a separate Task for each consumer:
        for (int i = 0; i < workerCount; i++)
            Task.Factory.StartNew(Consume);
    }

    public PCQueue(int workerCount, IProducerConsumerCollection<WorkItem> collection, int boundedCapacity)
    {
        _taskQ = new BlockingCollection<WorkItem>(collection, boundedCapacity);
        // Create and start a separate Task for each consumer:
        for (int i = 0; i < workerCount; i++)
            Task.Factory.StartNew(Consume);
    }

    public void Dispose() { _taskQ.CompleteAdding(); }

    public Task EnqueueTask(Action action)
    {
        return EnqueueTask(action, null);
    }

    public Task EnqueueTask(Action action, CancellationToken? cancelToken)
    {
        var tcs = new TaskCompletionSource<object>();
        _taskQ.Add(new WorkItem(tcs, action, cancelToken));
        return tcs.Task;
    }

    void Consume()
    {
        foreach (WorkItem workItem in _taskQ.GetConsumingEnumerable())
            if (workItem.CancelToken.HasValue &&
                workItem.CancelToken.Value.IsCancellationRequested)
            {
                workItem.TaskSource.SetCanceled();
            }
            else
                try
                {
                    workItem.Action();
                    workItem.TaskSource.SetResult(null);   // Indicate completion
                }
                catch (OperationCanceledException ex)
                {
                    if (ex.CancellationToken == workItem.CancelToken)
                        workItem.TaskSource.SetCanceled();
                    else
                        workItem.TaskSource.SetException(ex);
                }
                catch (Exception ex)
                {
                    workItem.TaskSource.SetException(ex);
                }
    }
}

再详细说明一下里面的WorkItem，包含了一个目标执行的Delegate以及TaskCompletionSource，通过在Enqueue时将TaskCompletionSource.Task返回给生产者，这样生产者可以通过返回的Task来知道现在WorkItem运行到了什么状态。

 

在Consume中，首先check task是否被cancel，这是通过传进来的Token的校验来完成的。在Enqueue时，可以使用如下代码传入Token。

var cancelSource = new CancellationTokenSource();
using (PCQueue queue = new PCQueue(1))
{
    queue.EnqueueTask(() =>
    {
        Thread.Sleep(3000);
    }, cancelSource.Token);


}

并在需要Cancel时，调用cancelSource.Cancel()，来实现未开始工作项的取消。

cancelSource.Cancel();

总结：本文由浅入深通过逐渐演化的方式实现了3种生产者消费者模型。用到的知识点有AutoResetEvent，Monitor.Wait & Monitor.Pluse，BlockingCollection，IProducerConsumerCollection，ConcurrentQueue...

 

Reference:

http://www.albahari.com/threading/ (墙裂推荐)