Creazione di una coda di blocco <T> in .NET?

Ho uno scenario in cui ho più thread che si aggiungono a una coda e più thread che leggono dalla stessa coda. Se la coda raggiunge una dimensione specifica, tutti i thread che riempiono la coda verranno bloccati durante l'aggiunta fino a quando un elemento non viene rimosso dalla coda.

La soluzione che segue è quella che sto usando in questo momento e la mia domanda è: come può essere migliorato? Esiste un oggetto che abilita già questo comportamento nel BCL che dovrei usare?

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();
        }
    }
}

Sembra molto pericoloso (pochissima sincronizzazione); che ne dici di qualcosa come:

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;
        }
    }
}

(modificare)

In realtà, vorresti un modo per chiudere la coda in modo che i lettori iniziassero a uscire in modo pulito - forse qualcosa come una bandiera bool - se impostato, una coda vuota restituisce (piuttosto che bloccare):

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;
    }
}

Usa .net 4 BlockingCollection, per accodare usa Add (), per accodare usa Take (). Utilizza internamente ConcurrentQueue non bloccante. Maggiori informazioni qui Veloce e migliore tecnica di coda produttore / consumatore BlockingCollection vs coda simultanea

"Come può essere migliorato?"

Bene, devi esaminare tutti i metodi della tua classe e considerare cosa accadrebbe se un altro thread chiamasse contemporaneamente quel metodo o qualsiasi altro metodo. Ad esempio, si inserisce un blocco nel metodo Rimuovi, ma non nel metodo Aggiungi. Cosa succede se un thread viene aggiunto contemporaneamente a un altro thread? Cose brutte.

Considera anche che un metodo può restituire un secondo oggetto che fornisce l'accesso ai dati interni del primo oggetto, ad esempio GetEnumerator. Immagina che un thread attraversi quell'enumeratore, un altro thread sta modificando l'elenco contemporaneamente. Non bene.

Una buona regola empirica è rendere questo più semplice da ottenere riducendo il numero di metodi della classe al minimo assoluto.

In particolare, non ereditare un'altra classe contenitore, perché esporrete tutti i metodi di quella classe, fornendo un modo per il chiamante di corrompere i dati interni o di vedere modifiche parzialmente complete ai dati (altrettanto male, perché i dati sembra corrotto in quel momento). Nascondi tutti i dettagli e sii completamente spietato su come permetterne l'accesso.

Ti consiglio vivamente di utilizzare soluzioni standardizzate: ottenere un libro sul threading o utilizzare una libreria di terze parti. Altrimenti, dato quello che stai tentando, eseguirai il debug del tuo codice per molto tempo.

Inoltre, non avrebbe più senso per Rimuovi restituire un elemento (ad esempio, quello che è stato aggiunto per primo, in quanto è una coda), piuttosto che il chiamante che sceglie un elemento specifico? E quando la coda è vuota, forse Rimuovi dovrebbe anche bloccare.

Aggiornamento: la risposta di Marc implementa effettivamente tutti questi suggerimenti! :) Ma lo lascerò qui perché potrebbe essere utile capire perché la sua versione è un tale miglioramento.

È possibile utilizzare BlockingCollection e ConcurrentQueue nello spazio dei nomi 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)
    {
    }



}

Ho appena rovinato tutto usando le estensioni reattive e mi sono ricordato di questa domanda:

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;
    }
}

Non necessariamente del tutto sicuro, ma molto semplice.

Questo è quello che mi è venuto in mente per una coda di blocco limitata da thread.

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;
    }
}

Non ho esplorato completamente il TPL, ma potrebbero avere qualcosa che si adatta alle tue esigenze, o almeno, un foraggio Reflector per trarre ispirazione.

Spero che aiuti.

Bene, potresti guardare la System.Threading.Semaphorelezione. A parte questo, no, devi farlo tu stesso. AFAIK non esiste una tale collezione integrata.

Se vuoi il massimo rendimento, consentendo a più lettori di leggere e solo uno scrittore di scrivere, BCL ha qualcosa chiamato ReaderWriterLockSlim che dovrebbe aiutarti a snellire il tuo codice ...