มีอะไรเช่น Asynchronous BlockingCollection <T> หรือไม่?

ฉันต้องการawaitผลลัพธ์ของBlockingCollection<T>.Take()แบบอะซิงโครนัสดังนั้นฉันจึงไม่บล็อกเธรด กำลังมองหาอะไรเช่นนี้:

var item = await blockingCollection.TakeAsync();

ฉันรู้ว่าฉันทำได้:

var item = await Task.Run(() => blockingCollection.Take());

แต่นั่นเป็นการฆ่าความคิดทั้งหมดเพราะเธรดอื่นThreadPoolถูกบล็อกแทน

มีทางเลือกอื่นไหม

มีสี่ทางเลือกที่ฉันรู้จัก

ประการแรกคือChannelsซึ่งจัดเตรียมคิวเธรดที่ปลอดภัยที่รองรับอะซิงโครนัสReadและWriteการดำเนินการ ช่องได้รับการปรับให้เหมาะสมอย่างมากและสามารถเลือกที่จะรองรับการทิ้งบางรายการได้หากถึงเกณฑ์

ถัดไปคือBufferBlock<T>จากTPL Dataflow หากคุณมีผู้บริโภคเพียงรายเดียวคุณสามารถใช้OutputAvailableAsyncหรือReceiveAsyncหรือเชื่อมโยงกับActionBlock<T>ไฟล์. สำหรับข้อมูลเพิ่มเติมโปรดดูที่บล็อกของฉัน

สุดท้ายทั้งสองประเภทที่ฉันสร้างที่มีอยู่ในของฉันห้องสมุด AsyncEx

AsyncCollection<T>เป็นasyncที่อยู่ใกล้เทียบเท่าของBlockingCollection<T>ความสามารถในการตัดผู้ผลิตพร้อมกันคอลเลกชันของผู้บริโภค / เช่นหรือConcurrentQueue<T> ConcurrentBag<T>คุณสามารถใช้TakeAsyncเพื่อใช้ไอเท็มจากคอลเลกชันแบบอะซิงโครนัสได้ สำหรับข้อมูลเพิ่มเติมโปรดดูที่บล็อกของฉัน

AsyncProducerConsumerQueue<T>เป็นasyncคิวผู้ผลิต / ผู้บริโภคแบบพกพาที่เข้ากันได้มากกว่า คุณสามารถใช้DequeueAsyncเพื่อใช้รายการจากคิวแบบอะซิงโครนัส สำหรับข้อมูลเพิ่มเติมโปรดดูที่บล็อกของฉัน

สามทางเลือกสุดท้ายเหล่านี้อนุญาตให้วางและใช้แบบซิงโครนัสและอะซิงโครนัส

... หรือคุณสามารถทำได้:

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

public class AsyncQueue<T>
{
    private readonly SemaphoreSlim _sem;
    private readonly ConcurrentQueue<T> _que;

    public AsyncQueue()
    {
        _sem = new SemaphoreSlim(0);
        _que = new ConcurrentQueue<T>();
    }

    public void Enqueue(T item)
    {
        _que.Enqueue(item);
        _sem.Release();
    }

    public void EnqueueRange(IEnumerable<T> source)
    {
        var n = 0;
        foreach (var item in source)
        {
            _que.Enqueue(item);
            n++;
        }
        _sem.Release(n);
    }

    public async Task<T> DequeueAsync(CancellationToken cancellationToken = default(CancellationToken))
    {
        for (; ; )
        {
            await _sem.WaitAsync(cancellationToken);

            T item;
            if (_que.TryDequeue(out item))
            {
                return item;
            }
        }
    }
}

คิว FIFO แบบอะซิงโครนัสที่ใช้งานง่ายและสมบูรณ์

หมายเหตุ: SemaphoreSlim.WaitAsyncถูกเพิ่มใน. NET 4.5 ก่อนหน้านั้นนี่ไม่ใช่ทั้งหมดที่ตรงไปตรงมา

นี่คือการใช้งานขั้นพื้นฐานBlockingCollectionที่รองรับการรอคอยพร้อมคุณสมบัติที่ขาดหายไปมากมาย ใช้AsyncEnumerableไลบรารีซึ่งทำให้การแจงนับแบบอะซิงโครนัสเป็นไปได้สำหรับเวอร์ชัน C # ที่เก่ากว่า 8.0

public class AsyncBlockingCollection<T>
{ // Missing features: cancellation, boundedCapacity, TakeAsync
    private Queue<T> _queue = new Queue<T>();
    private SemaphoreSlim _semaphore = new SemaphoreSlim(0);
    private int _consumersCount = 0;
    private bool _isAddingCompleted;

    public void Add(T item)
    {
        lock (_queue)
        {
            if (_isAddingCompleted) throw new InvalidOperationException();
            _queue.Enqueue(item);
        }
        _semaphore.Release();
    }

    public void CompleteAdding()
    {
        lock (_queue)
        {
            if (_isAddingCompleted) return;
            _isAddingCompleted = true;
            if (_consumersCount > 0) _semaphore.Release(_consumersCount);
        }
    }

    public IAsyncEnumerable<T> GetConsumingEnumerable()
    {
        lock (_queue) _consumersCount++;
        return new AsyncEnumerable<T>(async yield =>
        {
            while (true)
            {
                lock (_queue)
                {
                    if (_queue.Count == 0 && _isAddingCompleted) break;
                }
                await _semaphore.WaitAsync();
                bool hasItem;
                T item = default;
                lock (_queue)
                {
                    hasItem = _queue.Count > 0;
                    if (hasItem) item = _queue.Dequeue();
                }
                if (hasItem) await yield.ReturnAsync(item);
            }
        });
    }
}

ตัวอย่างการใช้งาน:

var abc = new AsyncBlockingCollection<int>();
var producer = Task.Run(async () =>
{
    for (int i = 1; i <= 10; i++)
    {
        await Task.Delay(100);
        abc.Add(i);
    }
    abc.CompleteAdding();
});
var consumer = Task.Run(async () =>
{
    await abc.GetConsumingEnumerable().ForEachAsync(async item =>
    {
        await Task.Delay(200);
        await Console.Out.WriteAsync(item + " ");
    });
});
await Task.WhenAll(producer, consumer);

เอาท์พุต:

1 2 3 4 5 6 7 8 9 10

อัปเดต:ด้วยการเปิดตัว C # 8 การแจงนับแบบอะซิงโครนัสได้กลายเป็นคุณลักษณะของภาษาในตัว คลาสที่จำเป็น ( IAsyncEnumerable, IAsyncEnumerator) ถูกฝังอยู่ใน. NET Core 3.0 และมีให้เป็นแพ็คเกจสำหรับ. NET Framework 4.6.1+ ( Microsoft.BclAsyncInterfaces )

นี่คือการGetConsumingEnumerableใช้งานทางเลือกที่มีไวยากรณ์ C # 8 ใหม่:

public async IAsyncEnumerable<T> GetConsumingEnumerable()
{
    lock (_queue) _consumersCount++;
    while (true)
    {
        lock (_queue)
        {
            if (_queue.Count == 0 && _isAddingCompleted) break;
        }
        await _semaphore.WaitAsync();
        bool hasItem;
        T item = default;
        lock (_queue)
        {
            hasItem = _queue.Count > 0;
            if (hasItem) item = _queue.Dequeue();
        }
        if (hasItem) yield return item;
    }
}

สังเกตการอยู่ร่วมกันawaitและyieldในวิธีการเดียวกัน

ตัวอย่างการใช้งาน (C # 8):

var consumer = Task.Run(async () =>
{
    await foreach (var item in abc.GetConsumingEnumerable())
    {
        await Task.Delay(200);
        await Console.Out.WriteAsync(item + " ");
    }
});

หมายเหตุawaitก่อนหน้าไฟล์foreach.

หากคุณไม่สนใจการแฮ็กเล็กน้อยคุณสามารถลองใช้ส่วนขยายเหล่านี้ได้

public static async Task AddAsync<TEntity>(
    this BlockingCollection<TEntity> Bc, TEntity item, CancellationToken abortCt)
{
    while (true)
    {
        try
        {
            if (Bc.TryAdd(item, 0, abortCt))
                return;
            else
                await Task.Delay(100, abortCt);
        }
        catch (Exception)
        {
            throw;
        }
    }
}

public static async Task<TEntity> TakeAsync<TEntity>(
    this BlockingCollection<TEntity> Bc, CancellationToken abortCt)
{
    while (true)
    {
        try
        {
            TEntity item;

            if (Bc.TryTake(out item, 0, abortCt))
                return item;
            else
                await Task.Delay(100, abortCt);
        }
        catch (Exception)
        {
            throw;
        }
    }
}