Tworzenie kolejki blokującej in.NET?

Użyj. Net 4 BlockingCollection, do enqueue użyj Add(), do dequeue użyj Take (). Wewnętrznie używa nieblokującego współbieżności. Więcej informacji tutaj Fast and Best Producer/consumer queue technique BlockingCollection vs concurrent Queue

" Jak można to poprawić?"

Cóż, musisz przyjrzeć się każdej metodzie w swojej klasie i zastanowić się, co by się stało, gdyby inny wątek wywoływał jednocześnie tę metodę lub jakąkolwiek inną metodę. Na przykład w metodzie Usuń umieszcza się blokadę, ale nie w metodzie Dodaj. Co się stanie, jeśli jeden wątek dodaje się w tym samym czasie, co inny wątek usuwa? Złe rzeczy.

Należy również wziąć pod uwagę, że metoda może zwrócić drugi obiekt, który zapewnia dostęp do pierwszego obiektu dane wewnętrzne-na przykład GetEnumerator. Wyobraź sobie, że jeden wątek przechodzi przez ten enumerator, inny wątek modyfikuje listę w tym samym czasie. Niedobrze.

Dobrą zasadą jest, aby to uprościć, zmniejszając liczbę metod w klasie do absolutnego minimum.

W szczególności, nie Dziedzicz innej klasy kontenera, ponieważ ujawnisz wszystkie metody tej klasy, zapewniając sposób, w jaki wywołujący może uszkodzić wewnętrzne dane lub aby zobaczyć częściowo kompletne zmiany danych(tak samo źle, ponieważ dane wydają się uszkodzone w tym momencie). Ukryj wszystkie szczegóły i bądź całkowicie bezwzględny w kwestii tego, jak zezwalasz na dostęp do nich.

Zdecydowanie odradzam korzystanie z gotowych rozwiązań - Kup książkę o gwintowaniu lub skorzystaj z biblioteki stron trzecich. W przeciwnym razie, biorąc pod uwagę to, co próbujesz, będziesz debugować swój kod przez długi czas.

Również, czy nie byłoby bardziej sensowne, aby usunąć, aby zwrócić przedmiot (powiedzmy, ten, który został dodany jako pierwszy, ponieważ jest to kolejka), a nie dzwoniący wybierając konkretny element? A gdy kolejka jest pusta, być może Usuń powinien również zablokować.

Aktualizacja: odpowiedź marca faktycznie realizuje wszystkie te sugestie! :) Ale zostawię to tutaj, ponieważ może być pomocne, aby zrozumieć, dlaczego jego wersja jest taka poprawa.

Możesz użyć BlockingCollectioni ConcurrentQueue w systemie.Kolekcje.Współbieżna Przestrzeń Nazw

 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)
    {
    }



}

Właśnie zapukałem to używając Reactive Extensions i przypomniałem sobie to pytanie:

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

To jest to, co przyszedłem op dla wątku Bezpieczny blokowania kolejki.

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

Nie do końca zbadałem TPL , ale mogą mieć coś, co pasuje do Twoich potrzeb, lub przynajmniej jakiś materiał odblaskowy, z którego możesz czerpać inspirację.

Mam nadzieję, że to pomoże.

Możesz spojrzeć na klasę. Poza tym-nie, musisz zrobić to sam. AFAIK nie ma takiej wbudowanej kolekcji.

Jeśli chcesz uzyskać maksymalną przepustowość, pozwalającą na odczyt wielu czytników i pisanie tylko jednego pisarza, BCL ma coś o nazwie ReaderWriterLockSlim, co powinno pomóc w odchudzeniu kodu...