Question

我正在使用BlockingCollection来实现生产者/消费者模式。我有一个异步循环，用于处理集合中要处理的数据，然后客户端可以在很晚的时候访问它。数据包稀疏地到达，我希望在不使用阻塞调用的情况下完成轮询。

本质上，我正在寻找阻塞集合中不存在的类似BeginTake和EndTake的东西，以便我可以在回调中使用内部线程池。它无论如何都不一定是BlockingCollection。任何做我需要的东西都会很棒。

这就是我现在所拥有的。 _bufferedPackets是BlockingCollection<byte[]>：

public byte[] Read(int timeout)
{
    byte[] result;
    if (_bufferedPackets.IsCompleted)
    {
        throw new Exception("Out of packets");
    }
    _bufferedPackets.TryTake(out result, timeout);      
    return result;
}

我希望这是类似的东西，在伪代码中：

public void Read(int timeout)
{
    _bufferedPackets.BeginTake(result =>
        {
            var bytes = _bufferedPackets.EndTake(result);
            // Process the bytes, or the resuting timeout
        }, timeout, _bufferedPackets);
}

我有什么选择？我不想将任何线程置于等待状态，因为它有很多其他IO内容需要处理，而且我会很快用完线程。

更新：我已经重写了有问题的代码，以不同的方式使用异步进程，基本上是根据超时限制内是否有等待请求来交换回调。这样可以正常工作，但如果有一种方法可以做到这一点而不诉诸定时器并交换lambdas可能导致竞争条件并且很难写（并理解），那么它仍然会很棒。我已经用自己的异步队列实现解决了这个问题，但如果有更标准且经过良好测试的选项，它仍然会很棒。

Answer 1

我可能误解了你的情况，但是你不能使用非阻塞集合吗？

我创建了这个例子来说明：

using System;
using System.Collections.Concurrent;
using System.Threading;
using System.Threading.Tasks;

namespace AsyncTakeFromBlockingCollection
{
    class Program
    {
        static void Main(string[] args)
        {
            var queue = new ConcurrentQueue<string>();

            var producer1 = Task.Factory.StartNew(() =>
            {
                for (int i = 0; i < 10; i += 1)
                {
                    queue.Enqueue("=======");
                    Thread.Sleep(10);
                }
            });

            var producer2 = Task.Factory.StartNew(() =>
            {
                for (int i = 0; i < 10; i += 1)
                {
                    queue.Enqueue("*******");
                    Thread.Sleep(3);
                }
            });

            CreateConsumerTask("One  ", 3, queue);
            CreateConsumerTask("Two  ", 4, queue);
            CreateConsumerTask("Three", 7, queue);

            producer1.Wait();
            producer2.Wait();
            Console.WriteLine("  Producers Finished");
            Console.ReadLine();
        }

        static void CreateConsumerTask(string taskName, int sleepTime, ConcurrentQueue<string> queue)
        {
            Task.Factory.StartNew(() =>
            {
                while (true)
                {
                    string result;
                    if (queue.TryDequeue(out result))
                    {
                        Console.WriteLine("  {0} consumed {1}", taskName, result);
                    }
                    Thread.Sleep(sleepTime);
                }
            });
        }
    }
}

这是程序的输出

enter image description here

我认为BlockingCollection旨在包装并发集合并提供允许多个消费者阻止的机制;等待生产者。这种用法似乎与您的要求相悖。

我发现此article about the BlockingCollection class有帮助。

Answer 2

所以看起来不是一个内置的选项，我出去试图尽我所能做我想做的实验。事实证明，为了使这项工作与旧的异步模式的其他用户大致相同，还有很多工作要做。

public class AsyncQueue<T>
{
    private readonly ConcurrentQueue<T> queue;
    private readonly ConcurrentQueue<DequeueAsyncResult> dequeueQueue; 

    private class DequeueAsyncResult : IAsyncResult
    {
        public bool IsCompleted { get; set; }
        public WaitHandle AsyncWaitHandle { get; set; }
        public object AsyncState { get; set; }
        public bool CompletedSynchronously { get; set; }
        public T Result { get; set; }

        public AsyncCallback Callback { get; set; }
    }

    public AsyncQueue()
    {
        dequeueQueue = new ConcurrentQueue<DequeueAsyncResult>();
        queue = new ConcurrentQueue<T>();
    }

    public void Enqueue(T item)
    {
        DequeueAsyncResult asyncResult;
        while  (dequeueQueue.TryDequeue(out asyncResult))
        {
            if (!asyncResult.IsCompleted)
            {
                asyncResult.IsCompleted = true;
                asyncResult.Result = item;

                ThreadPool.QueueUserWorkItem(state =>
                {
                    if (asyncResult.Callback != null)
                    {
                        asyncResult.Callback(asyncResult);
                    }
                    else
                    {
                        ((EventWaitHandle) asyncResult.AsyncWaitHandle).Set();
                    }
                });
                return;
            }
        }
        queue.Enqueue(item);
    }

    public IAsyncResult BeginDequeue(int timeout, AsyncCallback callback, object state)
    {
        T result;
        if (queue.TryDequeue(out result))
        {
            var dequeueAsyncResult = new DequeueAsyncResult
            {
                IsCompleted = true, 
                AsyncWaitHandle = new EventWaitHandle(true, EventResetMode.ManualReset), 
                AsyncState = state, 
                CompletedSynchronously = true, 
                Result = result
            };
            if (null != callback)
            {
                callback(dequeueAsyncResult);
            }
            return dequeueAsyncResult;
        }

        var pendingResult = new DequeueAsyncResult
        {
            AsyncState = state, 
            IsCompleted = false, 
            AsyncWaitHandle = new EventWaitHandle(false, EventResetMode.ManualReset), 
            CompletedSynchronously = false,
            Callback = callback
        };
        dequeueQueue.Enqueue(pendingResult);
        Timer t = null;
        t = new Timer(_ =>
        {
            if (!pendingResult.IsCompleted)
            {
                pendingResult.IsCompleted = true;
                if (null != callback)
                {
                    callback(pendingResult);
                }
                else
                {
                    ((EventWaitHandle)pendingResult.AsyncWaitHandle).Set();
                }
            }
            t.Dispose();
        }, new object(), timeout, Timeout.Infinite);

        return pendingResult;
    }

    public T EndDequeue(IAsyncResult result)
    {
        var dequeueResult = (DequeueAsyncResult) result;
        return dequeueResult.Result;
    }
}

我不太确定IsComplete属性的同步，而且我对dequeueQueue仅在后续Enqueue次调用中的清除方式不太热。我不确定何时是发出等待句柄的正确时间，但这是迄今为止我得到的最佳解决方案。

请不要以任何方式考虑此生产质量代码。我只想展示我如何在不等待锁定的情况下保持所有线程旋转的一般要点。我确信这里充满了各种各样的边缘情况和错误，但它符合要求，我想回答那些遇到问题的人。

Answer 3

我很确定BlockingCollection<T>无法做到这一点，你必须自己动手。我想出了这个：

class NotifyingCollection<T>
{
    private ConcurrentQueue<Action<T>> _subscribers = new ConcurrentQueue<Action<T>>();
    private ConcurrentQueue<T> _overflow = new ConcurrentQueue<T>();

    private object _lock = new object();

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

    private void Dispatch()
    {
        // this lock is needed since we need to atomically dequeue from both queues...
        lock (_lock)
        {
            while (_overflow.Count > 0 && _subscribers.Count > 0)
            {
                Action<T> callback;
                T item;

                var r1 = _overflow.TryDequeue(out item);
                var r2 = _subscribers.TryDequeue(out callback);

                Debug.Assert(r1 && r2);
                callback(item);
                // or, optionally so that the caller thread's doesn't take too long ...
                Task.Factory.StartNew(() => callback(item));
                // but you'll have to consider how exceptions will be handled.
            }
        }
    }

    public void TakeAsync(Action<T> callback)
    {
        _subscribers.Enqueue(callback);
        Dispatch();
    }
}

我使用了调用TakeAsync()或Add()的线程作为回调线程。当您呼叫Add()或TakeAsync()时，它会尝试将所有排队的项目分配给排队的回调。这样就没有创建只是坐在那里休息的线程，等待发出信号。

那个锁很难看，但是你可以在没有锁定的情况下在多个线程上排队和订阅。如果在没有使用该锁的情况下，如果其他队列中有可用的内容，我就无法找到一种方法来执行等效的只出列一个。

注意：我只用最少的线程测试了这个。

从阻塞集合中异步获取

3 个答案: