Створення черги блокування <T> у .NET?

У мене є сценарій, коли я додаю до черги кілька потоків і читання декількох потоків з однієї черги. Якщо черга досягає певного розміру, всі потоки , які заповнюють чергу, будуть заблоковані при додаванні, поки елемент не буде видалений з черги.

Нижче наведено рішення, яким я зараз користуюся, і моє запитання: як це можна покращити? Чи є об'єкт, який вже дозволяє цю поведінку в BCL, який я повинен використовувати?

internal class BlockingCollection<T> : CollectionBase, IEnumerable
{
    //todo: might be worth changing this into a proper QUEUE

    private AutoResetEvent _FullEvent = new AutoResetEvent(false);

    internal T this[int i]
    {
        get { return (T) List[i]; }
    }

    private int _MaxSize;
    internal int MaxSize
    {
        get { return _MaxSize; }
        set
        {
            _MaxSize = value;
            checkSize();
        }
    }

    internal BlockingCollection(int maxSize)
    {
        MaxSize = maxSize;
    }

    internal void Add(T item)
    {
        Trace.WriteLine(string.Format("BlockingCollection add waiting: {0}", Thread.CurrentThread.ManagedThreadId));

        _FullEvent.WaitOne();

        List.Add(item);

        Trace.WriteLine(string.Format("BlockingCollection item added: {0}", Thread.CurrentThread.ManagedThreadId));

        checkSize();
    }

    internal void Remove(T item)
    {
        lock (List)
        {
            List.Remove(item);
        }

        Trace.WriteLine(string.Format("BlockingCollection item removed: {0}", Thread.CurrentThread.ManagedThreadId));
    }

    protected override void OnRemoveComplete(int index, object value)
    {
        checkSize();
        base.OnRemoveComplete(index, value);
    }

    internal new IEnumerator GetEnumerator()
    {
        return List.GetEnumerator();
    }

    private void checkSize()
    {
        if (Count < MaxSize)
        {
            Trace.WriteLine(string.Format("BlockingCollection FullEvent set: {0}", Thread.CurrentThread.ManagedThreadId));
            _FullEvent.Set();
        }
        else
        {
            Trace.WriteLine(string.Format("BlockingCollection FullEvent reset: {0}", Thread.CurrentThread.ManagedThreadId));
            _FullEvent.Reset();
        }
    }
}

Це виглядає дуже небезпечно (дуже мало синхронізації); як щодо чогось типу:

class SizeQueue<T>
{
    private readonly Queue<T> queue = new Queue<T>();
    private readonly int maxSize;
    public SizeQueue(int maxSize) { this.maxSize = maxSize; }

    public void Enqueue(T item)
    {
        lock (queue)
        {
            while (queue.Count >= maxSize)
            {
                Monitor.Wait(queue);
            }
            queue.Enqueue(item);
            if (queue.Count == 1)
            {
                // wake up any blocked dequeue
                Monitor.PulseAll(queue);
            }
        }
    }
    public T Dequeue()
    {
        lock (queue)
        {
            while (queue.Count == 0)
            {
                Monitor.Wait(queue);
            }
            T item = queue.Dequeue();
            if (queue.Count == maxSize - 1)
            {
                // wake up any blocked enqueue
                Monitor.PulseAll(queue);
            }
            return item;
        }
    }
}

(редагувати)

Насправді, ви хочете, щоб закрити чергу, щоб читачі почали чисто виходити - можливо, щось на зразок прапора bool - якщо встановлено, порожня черга просто повертається (а не блокується):

bool closing;
public void Close()
{
    lock(queue)
    {
        closing = true;
        Monitor.PulseAll(queue);
    }
}
public bool TryDequeue(out T value)
{
    lock (queue)
    {
        while (queue.Count == 0)
        {
            if (closing)
            {
                value = default(T);
                return false;
            }
            Monitor.Wait(queue);
        }
        value = queue.Dequeue();
        if (queue.Count == maxSize - 1)
        {
            // wake up any blocked enqueue
            Monitor.PulseAll(queue);
        }
        return true;
    }
}

Використовуйте .net 4 BlockingCollection, щоб застосувати додавання Add (), щоб припинити використання Take (). Він внутрішньо використовує неблокуючу ConcurrentQueue. Більше інформації тут Швидка та найкраща техніка черг для виробників / споживачів BlockingCollection vs паралельна черга

"Як це можна покращити?"

Ну, вам потрібно переглянути кожен метод вашого класу і подумати, що буде, якби інший потік одночасно викликав цей метод чи будь-який інший метод. Наприклад, ви ставите замок у методі Remove, але не у методі Add. Що станеться, якщо один потік додається одночасно з іншим потоком видалення? Погані речі.

Також врахуйте, що метод може повернути другий об'єкт, який забезпечує доступ до внутрішніх даних першого об'єкта - наприклад, GetEnumerator. Уявіть, що один потік проходить через цей нумератор, інший - одночасно змінює список. Не добре.

Добре правило полягає в тому, щоб зробити це більш простим, як правильно, скоротивши кількість методів у класі до абсолютного мінімуму.

Зокрема, не успадковуйте інший клас контейнерів, оскільки ви відкриєте всі методи цього класу, надаючи спосіб абоненту пошкодити внутрішні дані або побачити частково повні зміни даних (так само погано, оскільки дані здається зіпсованим в цей момент). Сховайте всі деталі та будьте абсолютно нещадні щодо того, як ви дозволяєте їм отримати доступ.

Я б настійно радив вам скористатись нестандартними рішеннями - отримати книгу про нарізання різьби або використовувати сторонні бібліотеки. Інакше, враховуючи те, що ви намагаєтесь, ви довго будете налагоджувати код.

Крім того, чи не було б більше сенсу для Remove повертати елемент (скажімо, той, який був доданий першим, оскільки це черга), а не той, хто викликає, хто вибирає конкретний елемент? І коли черга порожня, можливо, Remove також слід заблокувати.

Оновлення: Відповідь Марка реально реалізує всі ці пропозиції! :) Але я залишу це тут, оскільки це може бути корисно зрозуміти, чому його версія - це таке вдосконалення.

Ви можете використовувати BlockingCollection і ConcurrentQueue в System.Collections.Concurrent Іменний простір

 public class ProducerConsumerQueue<T> : BlockingCollection<T>
{
    /// <summary>
    /// Initializes a new instance of the ProducerConsumerQueue, Use Add and TryAdd for Enqueue and TryEnqueue and Take and TryTake for Dequeue and TryDequeue functionality
    /// </summary>
    public ProducerConsumerQueue()  
        : base(new ConcurrentQueue<T>())
    {
    }

  /// <summary>
  /// Initializes a new instance of the ProducerConsumerQueue, Use Add and TryAdd for Enqueue and TryEnqueue and Take and TryTake for Dequeue and TryDequeue functionality
  /// </summary>
  /// <param name="maxSize"></param>
    public ProducerConsumerQueue(int maxSize)
        : base(new ConcurrentQueue<T>(), maxSize)
    {
    }



}

Я просто збив це за допомогою реактивних розширень і згадав це питання:

public class BlockingQueue<T>
{
    private readonly Subject<T> _queue;
    private readonly IEnumerator<T> _enumerator;
    private readonly object _sync = new object();

    public BlockingQueue()
    {
        _queue = new Subject<T>();
        _enumerator = _queue.GetEnumerator();
    }

    public void Enqueue(T item)
    {
        lock (_sync)
        {
            _queue.OnNext(item);
        }
    }

    public T Dequeue()
    {
        _enumerator.MoveNext();
        return _enumerator.Current;
    }
}

Не обов’язково цілком безпечний, але дуже простий.

Це те, що я прийшов до черги блокування безпечного обмеженого потоку.

using System;
using System.Collections.Generic;
using System.Text;
using System.Threading;

public class BlockingBuffer<T>
{
    private Object t_lock;
    private Semaphore sema_NotEmpty;
    private Semaphore sema_NotFull;
    private T[] buf;

    private int getFromIndex;
    private int putToIndex;
    private int size;
    private int numItems;

    public BlockingBuffer(int Capacity)
    {
        if (Capacity <= 0)
            throw new ArgumentOutOfRangeException("Capacity must be larger than 0");

        t_lock = new Object();
        buf = new T[Capacity];
        sema_NotEmpty = new Semaphore(0, Capacity);
        sema_NotFull = new Semaphore(Capacity, Capacity);
        getFromIndex = 0;
        putToIndex = 0;
        size = Capacity;
        numItems = 0;
    }

    public void put(T item)
    {
        sema_NotFull.WaitOne();
        lock (t_lock)
        {
            while (numItems == size)
            {
                Monitor.Pulse(t_lock);
                Monitor.Wait(t_lock);
            }

            buf[putToIndex++] = item;

            if (putToIndex == size)
                putToIndex = 0;

            numItems++;

            Monitor.Pulse(t_lock);

        }
        sema_NotEmpty.Release();


    }

    public T take()
    {
        T item;

        sema_NotEmpty.WaitOne();
        lock (t_lock)
        {

            while (numItems == 0)
            {
                Monitor.Pulse(t_lock);
                Monitor.Wait(t_lock);
            }

            item = buf[getFromIndex++];

            if (getFromIndex == size)
                getFromIndex = 0;

            numItems--;

            Monitor.Pulse(t_lock);

        }
        sema_NotFull.Release();

        return item;
    }
}

Я не до кінця вивчив TPL, але у них може бути щось, що відповідає вашим потребам, або, принаймні, якийсь кормовий відбивач, щоб вирвати деякий натхнення.

Сподіваюся, що це допомагає.

Ну, ви можете подивитися на System.Threading.Semaphoreзаняття. Крім цього - ні, ви повинні зробити це самостійно. AFAIK немає такої вбудованої колекції.

Якщо ви хочете отримати максимальну пропускну спроможність, дозволяючи читачам читати і писати лише один автор, BCL має щось, що називається ReaderWriterLockSlim, що повинно допомогти зменшити код ...