无需BlockingCollection的简单生产者-消费者集合

Question

I want to write a simple producer-consumer queue, without using the built-in System.Collections.Concurrent.BlockingCollection . Here's a quick attempt that "seems" to work. Is there anything wrong with it threading-wise, race conditions, deadlocks etc.?

class ProducerConsumerQueue<T>
{
    Queue<T> Queue = new Queue<T>();
    ManualResetEvent Event = new ManualResetEvent(false);
    object Lock = new object();

    public void Add(T t)
    {
        lock (Lock)
        {
            Queue.Enqueue(t);
        }
        Event.Set();
    }

    public bool TryTake(out T t, int timeout)
    {
        if (Event.WaitOne(timeout))
        {
            lock (Lock)
            {
                if (Queue.Count > 0)
                {
                    t = Queue.Dequeue();
                    if (Queue.Count == 0) Event.Reset();
                    return true;
                }
            }
        }
        t = default(T);
        return false;
    }
}

Btw. the only two methods I need are Add and TryTake , I don't need IEnumerable etc.

Answer 1

I think using both lock and a ManualResetEvent is redundant. I suggest you read more about ManualResetEvent on how to enter and exit synchronized areas in your code (you can also take a look at other synchronization mechanisms available under System.Threading ).

If it's not just for exercise, you can also take a look at NetMQ .

Hope it helps!

Answer 2

Microsoft recently dropped System.Threading.Channels , which is intended to provide optimized producer/consumer APIs, which may be a good fit in this case. It covers unbounded and bounded scenarios, and includes single plus multiple reader/writer scenarios. The API is pretty simple and intuitive to use; the only slight caveat is that it uses an async -orientated API (for the consumer, and - in the case of bounded channels - for the producer).

The point here being: the code you don't write tends to be code that has fewer pain points - especially if it was written by a team with expertise and interest in the specific problems being targeted.

---

However: you can do everything in your current code without needing the ManualResetEvent - lock in C# is just a wrapper around the simplest parts of Monitor , but Monitor also provides wait/pulse functionality:

class ProducerConsumerQueue<T>
{
    private readonly Queue<T> Queue = new Queue<T>();

    public void Add(T t)
    {
        lock (Queue)
        {
            Queue.Enqueue(t);
            if (Queue.Count == 1)
            {
                // wake up one sleeper
                Monitor.Pulse(Queue);
            }
        }
    }

    public bool TryTake(out T t, int millisecondsTimeout)
    {
        lock (Queue)
        {
            if (Queue.Count == 0)
            {
                // try and wait for arrival
                Monitor.Wait(Queue, millisecondsTimeout);
            }
            if (Queue.Count != 0)
            {
                t = Queue.Dequeue();
                return true;
            }
        }
        t = default(T);
        return false;
    }
}

Answer 3

As per my comment in the question,

Here is a my proposed solution.

public class BlockingQueue<T>
{
    // In order to get rid of Lock object
    // Any thread should be able to add items to the queue
    private readonly ConcurrentQueue<T> _queue = new ConcurrentQueue<T>();

    // Only one thread is able to consume from queue
    // You can fine tune this to your interest
    private readonly SemaphoreSlim _slim = new SemaphoreSlim(1,1);

    public void Add(T item) {
        _queue.Enqueue(item);
    }

    public bool TryTake(out T item, TimeSpan timeout) {
        if (_slim.Wait(timeout)){
            return _queue.TryDequeue(out item);
        }
        item = default(T);
        return false;
    }
}