Question

我有一个在队列中添加数据的线程，现在我希望在添加数据时通知其他线程，以便它可以从队列开始处理数据。

一个选项是线程将连续轮询队列以查看计数是否大于零但我认为这不是好方法，任何其他建议将不胜感激

任何建议如何实现这一点，我使用的是.net framework 3.5。

如果我有两个线程1正在做q.Enqueue(data)而另一个正在做q.dequeue()怎么办？在这种情况下我需要管理锁..？

Answer 1

您可以使用ManualResetEvent通知线程。

ManualResetEvent e = new ManualResetEvent(false);

在每个q.enqueue();执行e.Set()之后，在处理线程中，您等待e.WaitOne()的项目。

如果你在循环中进行处理，你应该在e.Reset()之后立即e.WaitOne()。

Answer 2

我不使用队列，因为我宁愿批量处理它们。当您必须打开/关闭（日志）文件，打开/关闭数据库时，这更有用。以下是我如何创建这样的示例：

// J. van Langen
public abstract class QueueHandler<T> : IDisposable
{
    // some events to trigger.
    ManualResetEvent _terminating = new ManualResetEvent(false);
    ManualResetEvent _terminated = new ManualResetEvent(false);
    AutoResetEvent _needProcessing = new AutoResetEvent(false);

    // my 'queue'
    private List<T> _queue = new List<T>();

    public QueueHandler()
    {
        new Thread(new ThreadStart(() =>
        {
            // what handles it should wait on.
            WaitHandle[] handles = new WaitHandle[] { _terminating, _needProcessing };

            // while not terminating, loop (0 timeout)
            while (!_terminating.WaitOne(0))
            {
                // wait on the _terminating and the _needprocessing handle.
                WaitHandle.WaitAny(handles);

                // my temporay array to store the current items.
                T[] itemsCopy;

                // lock the queue
                lock (_queue)
                {
                    // create a 'copy'
                    itemsCopy = _queue.ToArray();

                    // clear the queue.
                    _queue.Clear();
                }

                if (itemsCopy.Length > 0)
                    HandleItems(itemsCopy);
            }

            // the thread is done.
            _terminated.Set();

        })).Start();
    }

    public abstract void HandleItems(T[] items);

    public void Enqueue(T item)
    {
        // lock the queue to add the item.
        lock (_queue)
            _queue.Add(item);

        _needProcessing.Set();
    }

    // batch
    public void Enqueue(IEnumerable<T> items)
    {
        // lock the queue to add multiple items.
        lock (_queue)
            _queue.AddRange(items);

        _needProcessing.Set();
    }

    public void Dispose()
    {
        // let the thread know it should stop.
        _terminating.Set();

        // wait until the thread is stopped.
        _terminated.WaitOne();
    }

}

对于_terminating / _terminated，我使用ManualResetEvent，因为这些只是设置的。

对于_needProcessing，我使用AutoResetEvent无法使用ManualResetEvent，因为当它被触发时，另一个线程可以再次Set，所以如果你{{1}在WaitHandle.WaitAny之后你可以撤消新添加的项目。（嗯，如果有人能解释这个更容易，欢迎。）

示例：

Reset

Answer 3

使用BlockingCollection课程。关于它的好处是Take方法阻塞（没有轮询）队列是否为空。它包含在.NET 4.0+中或作为Reactive Extension下载的一部分，甚至可能包含在TPL backport via NuGet中。如果您愿意，可以使用以下未经优化的班级变体。

public class BlockingCollection<T>
{
    private readonly Queue<T> m_Queue = new Queue<T>();

    public void Add(T item)
    {
        lock (m_Queue)
        {
            m_Queue.Enqueue(item);
            Monitor.Pulse(m_Queue);
        }
    }

    public T Take()
    {
        lock (m_Queue)
        {
            while (m_Queue.Count == 0)
            {
                Monitor.Wait(m_Queue);
            }
            return m_Queue.Dequeue();
        }
    }

    public bool TryTake(out T item)
    {
        item = default(T);
        lock (m_Queue)
        {
            if (m_Queue.Count > 0)
            {
                item = m_Queue.Dequeue();
            }
        }
        return item != null;
    }

}

Answer 4

我认为BlockingCollection会比Queue更好。除此之外，不断检查队列大小（并在线程为零时暂停线程）是非常好的方法。

顺便说一下，我们在这里谈论生产者 - 消费者模式。我想你可以通过谷歌搜索其他方法。

在队列中添加数据时通知线程

4 个答案: