检查队列不断地

Question

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

显然可以选择带有睡眠的连续循环，但我想要一些不那么浪费的东西。

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

现在我正在考虑封装一个 Queue 作为我的最佳选择，但我想问一下各位好心人是否有更好的选择！

我的想法是：我希望许多线程访问套接字连接，同时保证它们只读取消息的响应，因此我将有一个线程分派并读取响应，然后使用响应数据（以纯文本形式）执行回调

Answer 1

尝试阻塞队列：创建阻塞队列在 .NET 中？

基本思想是，当您调用 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！