我想知道是否存在ConcurrentQueue的实现/包装器，类似于BlockingCollection，其中从集合中获取不会阻塞，而是异步并且将导致异步等待直到项目被放入队列中。
我已经提出了自己的实现，但它似乎没有按预期执行。我想知道我是否正在重塑已经存在的东西。
这是我的实施：
public class MessageQueue<T>
{
ConcurrentQueue<T> queue = new ConcurrentQueue<T>();
ConcurrentQueue<TaskCompletionSource<T>> waitingQueue =
new ConcurrentQueue<TaskCompletionSource<T>>();
object queueSyncLock = new object();
public void Enqueue(T item)
{
queue.Enqueue(item);
ProcessQueues();
}
public async Task<T> Dequeue()
{
TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
waitingQueue.Enqueue(tcs);
ProcessQueues();
return tcs.Task.IsCompleted ? tcs.Task.Result : await tcs.Task;
}
private void ProcessQueues()
{
TaskCompletionSource<T> tcs=null;
T firstItem=default(T);
while (true)
{
bool ok;
lock (queueSyncLock)
{
ok = waitingQueue.TryPeek(out tcs) && queue.TryPeek(out firstItem);
if (ok)
{
waitingQueue.TryDequeue(out tcs);
queue.TryDequeue(out firstItem);
}
}
if (!ok) break;
tcs.SetResult(firstItem);
}
}
}
答案 0 :(得分：48)
我不知道无锁解决方案，但您可以查看Dataflow library的新Async CTP部分。一个简单的BufferBlock<T>就足够了，例如：
BufferBlock<int> buffer = new BufferBlock<int>();
通过数据流块类型的扩展方法可以轻松完成生产和消费。
生产就像：
buffer.Post(13);
int item = await buffer.ReceiveAsync();
我建议您尽可能使用Dataflow;使这样的缓冲区既高效又正确，比最初出现的要困难得多。
答案 1 :(得分：6)
一种简单的实现方法是使用SemaphoreSlim：
public class AwaitableQueue<T>
{
private SemaphoreSlim semaphore = new SemaphoreSlim(0);
private readonly object queueLock = new object();
private Queue<T> queue = new Queue<T>();
public void Enqueue(T item)
{
lock (queueLock)
{
queue.Enqueue(item);
semaphore.Release();
}
}
public T WaitAndDequeue(TimeSpan timeSpan, CancellationToken cancellationToken)
{
semaphore.Wait(timeSpan, cancellationToken);
lock (queueLock)
{
return queue.Dequeue();
}
}
public async Task<T> WhenDequeue(TimeSpan timeSpan, CancellationToken cancellationToken)
{
await semaphore.WaitAsync(timeSpan, cancellationToken);
lock (queueLock)
{
return queue.Dequeue();
}
}
}
这样做的好处是SemaphoreSlim处理实现Wait()和WaitAsync()功能的所有复杂性。缺点是队列长度由信号量和队列本身跟踪，并且它们都神奇地保持同步。
答案 2 :(得分：6)
现在有一种官方方法可以做到这一点：System.Threading.Channels。它内置于 .NET Core 3.0 及更高版本（包括 .NET 5.0 和 6.0）的核心运行时中，但它也可作为 .NET Standard 2.0 和 2.1 上的 NuGet 包使用。您可以通读文档 here。
var channel = System.Threading.Channels.Channel.CreateUnbounded<int>();
排队工作：
// This will succeed and finish synchronously if the channel is unbounded.
channel.Writer.TryWrite(42);
完成频道：
channel.Writer.TryComplete();
从频道中读取：
var i = await channel.Reader.ReadAsync();
或者，如果您有 .NET Core 3.0 或更高版本：
await foreach (int i in channel.Reader.ReadAllAsync())
{
// whatever processing on i...
}
答案 3 :(得分：3)
IAsyncEnumerable和Dataflow library的简单方法// Instatiate an async queue
var queue = new AsyncQueue<int>();
// Then, loop through the elements of queue.
// This loop won't stop until it is canceled or broken out of
// (for that, use queue.WithCancellation(..) or break;)
await foreach(int i in queue) {
// Writes a line as soon as some other Task calls queue.Enqueue(..)
Console.WriteLine(i);
}
使用AsyncQueue的实现如下：
public class AsyncQueue<T> : IAsyncEnumerable<T>
{
private readonly SemaphoreSlim _enumerationSemaphore = new SemaphoreSlim(1);
private readonly BufferBlock<T> _bufferBlock = new BufferBlock<T>();
public void Enqueue(T item) =>
_bufferBlock.Post(item);
public async IAsyncEnumerator<T> GetAsyncEnumerator(CancellationToken token = default)
{
// We lock this so we only ever enumerate once at a time.
// That way we ensure all items are returned in a continuous
// fashion with no 'holes' in the data when two foreach compete.
await _enumerationSemaphore.WaitAsync();
try {
// Return new elements until cancellationToken is triggered.
while (!token.IsCancellationRequested) {
yield return await _bufferBlock.ReceiveAsync(token);
}
} finally {
_enumerationSemaphore.Release();
}
}
}
答案 4 :(得分：2)
我的尝试（当创建＆＃34; promise＆＃34;时会产生一个事件，并且外部生产者可以使用它来知道何时生成更多项目）：
public class AsyncQueue<T>
{
private ConcurrentQueue<T> _bufferQueue;
private ConcurrentQueue<TaskCompletionSource<T>> _promisesQueue;
private object _syncRoot = new object();
public AsyncQueue()
{
_bufferQueue = new ConcurrentQueue<T>();
_promisesQueue = new ConcurrentQueue<TaskCompletionSource<T>>();
}
/// <summary>
/// Enqueues the specified item.
/// </summary>
/// <param name="item">The item.</param>
public void Enqueue(T item)
{
TaskCompletionSource<T> promise;
do
{
if (_promisesQueue.TryDequeue(out promise) &&
!promise.Task.IsCanceled &&
promise.TrySetResult(item))
{
return;
}
}
while (promise != null);
lock (_syncRoot)
{
if (_promisesQueue.TryDequeue(out promise) &&
!promise.Task.IsCanceled &&
promise.TrySetResult(item))
{
return;
}
_bufferQueue.Enqueue(item);
}
}
/// <summary>
/// Dequeues the asynchronous.
/// </summary>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public Task<T> DequeueAsync(CancellationToken cancellationToken)
{
T item;
if (!_bufferQueue.TryDequeue(out item))
{
lock (_syncRoot)
{
if (!_bufferQueue.TryDequeue(out item))
{
var promise = new TaskCompletionSource<T>();
cancellationToken.Register(() => promise.TrySetCanceled());
_promisesQueue.Enqueue(promise);
this.PromiseAdded.RaiseEvent(this, EventArgs.Empty);
return promise.Task;
}
}
}
return Task.FromResult(item);
}
/// <summary>
/// Gets a value indicating whether this instance has promises.
/// </summary>
/// <value>
/// <c>true</c> if this instance has promises; otherwise, <c>false</c>.
/// </value>
public bool HasPromises
{
get { return _promisesQueue.Where(p => !p.Task.IsCanceled).Count() > 0; }
}
/// <summary>
/// Occurs when a new promise
/// is generated by the queue
/// </summary>
public event EventHandler PromiseAdded;
}
答案 5 :(得分：1)
对于您的用例（考虑到学习曲线）可能有点过分，但Reactive Extentions提供了您可能想要的异步合成的所有粘合剂。
您实际上订阅了更改，并在它们可用时将它们推送给您，您可以让系统在单独的线程上推送更改。
答案 6 :(得分：0)
检出https://github.com/somdoron/AsyncCollection，您既可以异步出队，也可以使用C＃8.0 IAsyncEnumerable。
API与BlockingCollection非常相似。
AsyncCollection<int> collection = new AsyncCollection<int>();
var t = Task.Run(async () =>
{
while (!collection.IsCompleted)
{
var item = await collection.TakeAsync();
// process
}
});
for (int i = 0; i < 1000; i++)
{
collection.Add(i);
}
collection.CompleteAdding();
t.Wait();
使用IAsyncEnumeable：
AsyncCollection<int> collection = new AsyncCollection<int>();
var t = Task.Run(async () =>
{
await foreach (var item in collection)
{
// process
}
});
for (int i = 0; i < 1000; i++)
{
collection.Add(i);
}
collection.CompleteAdding();
t.Wait();
答案 7 :(得分：0)
8年后，我遇到了这个问题，打算实现在nuget包/命名空间中找到的MS driver.find_element_by_xpath("//label[@for='country_12']").click()
类： Microsoft.VisualStudio.Threading
感谢@Theodor Zoulias提及此api可能已过时，DataFlow库将是一个不错的选择。
所以我编辑了AsyncQueue <>实现以使用BufferBlock <>。几乎相同，但效果更好。
我在AspNet Core后台线程中使用它，并且它完全异步运行。
AsyncQueue<T>我发现使用队列.OutputAvailableAsync（）解决了AsyncQueue <>的问题-尝试确定队列何时完成而不必检查出队任务。
答案 8 :(得分：-1)
这是我目前正在使用的实现。
public class MessageQueue<T>
{
ConcurrentQueue<T> queue = new ConcurrentQueue<T>();
ConcurrentQueue<TaskCompletionSource<T>> waitingQueue =
new ConcurrentQueue<TaskCompletionSource<T>>();
object queueSyncLock = new object();
public void Enqueue(T item)
{
queue.Enqueue(item);
ProcessQueues();
}
public async Task<T> DequeueAsync(CancellationToken ct)
{
TaskCompletionSource<T> tcs = new TaskCompletionSource<T>();
ct.Register(() =>
{
lock (queueSyncLock)
{
tcs.TrySetCanceled();
}
});
waitingQueue.Enqueue(tcs);
ProcessQueues();
return tcs.Task.IsCompleted ? tcs.Task.Result : await tcs.Task;
}
private void ProcessQueues()
{
TaskCompletionSource<T> tcs = null;
T firstItem = default(T);
lock (queueSyncLock)
{
while (true)
{
if (waitingQueue.TryPeek(out tcs) && queue.TryPeek(out firstItem))
{
waitingQueue.TryDequeue(out tcs);
if (tcs.Task.IsCanceled)
{
continue;
}
queue.TryDequeue(out firstItem);
}
else
{
break;
}
tcs.SetResult(firstItem);
}
}
}
}
它工作得很好，但queueSyncLock上存在很多争用，因为我正在大量使用CancellationToken取消一些等待任务。当然，这会导致我使用BlockingCollection看到的阻塞大大减少但是......
我想知道是否有更顺畅，无锁的方法来实现同样的目的
答案 9 :(得分：-3)
您可以使用BlockingCollection（使用默认ConcurrentQueue）并将来电Take包裹在Task中，这样您就可以await：
var bc = new BlockingCollection<T>();
T element = await Task.Run( () => bc.Take() );