连续检查队列<T>

Question

我想要一个函数在一个线程上连续检查队列是否有新的添加

显然,可以选择连续循环播放睡眠,但我希望减少浪费.

我考虑了某种类型的等待句柄,然后让队列发出信号,但我无法安全地覆盖Enqueue,因为它不是虚拟的.

现在我正在考虑封装一个Queue<T>作为我最好的选择,但我想问你好人,如果有更好的人!

我的想法是:我希望许多线程访问套接字连接,同时保证他们只读取其消息的响应,所以我将有一个线程调度和读取响应,然后用响应数据执行回调(以纯文本格式)

Answer 1

尝试阻塞队列:在.NET中创建阻塞队列<T>？

基本的想法是,当你调用TryDequeue它时会阻塞,直到队列中有东西.你可以看到阻塞队列的"美丽"是你不必轮询/睡觉或做任何疯狂的事情......它是生产者/消费者模式的基本支柱.

我的阻塞队列版本是:

public class BlockingQueue<T> where T : class
{
    private bool closing;
    private readonly Queue<T> queue = new Queue<T>();

    public int Count
    {
        get
        {
            lock (queue)
            {
                return queue.Count;
            }
        }
    }

    public BlockingQueue()
    {
        lock (queue)
        {
            closing = false;
            Monitor.PulseAll(queue);
        }
    }

    public bool Enqueue(T item)
    {
        lock (queue)
        {
            if (closing || null == item)
            {
                return false;
            }

            queue.Enqueue(item);

            if (queue.Count == 1)
            {
                // wake up any blocked dequeue
                Monitor.PulseAll(queue);
            }

            return true;
        }
    }


    public void Close()
    {
        lock (queue)
        {
            if (!closing)
            {
                closing = true;
                queue.Clear();
                Monitor.PulseAll(queue);
            }
        }
    }


    public bool TryDequeue(out T value, int timeout = Timeout.Infinite)
    {
        lock (queue)
        {
            while (queue.Count == 0)
            {
                if (closing || (timeout < Timeout.Infinite) || !Monitor.Wait(queue, timeout))
                {
                    value = default(T);
                    return false;
                }
            }

            value = queue.Dequeue();
            return true;
        }
    }

    public void Clear()
    {
        lock (queue)
        {
            queue.Clear();
            Monitor.Pulse(queue);
        }
    }
}

非常感谢Marc Gravell为这一个!