Wie implementiere ich eine thread-safe Blocking-Warteschlange in .NET?

Erstellen einer fadenfesten blockierenden Warteschlange in .NET

Multithread -Anwendungen erfordern häufig eine gemeinsame Warteschlange, in der mehrere Threads gleichzeitig Elemente hinzufügen und abrufen. Eine blockierende Warteschlange ist dafür ideal, bei der Warteschlange pausiert, wenn die Warteschlange in der Warteschlange pausiert, wenn die Warteschlange leer ist.

Eine robuste Blockierungswarteschlange

Die folgende verbesserte Implementierung befasst sich mit potenziellen Rassenbedingungen mit Monitor für die Synchronisation und bietet einen anmutigen Verschlussmechanismus:

SizeQueue<T> Implementierung

In diesem Beispiel wird ein synchronisiertes Queue<T> und Monitor für eine effiziente Fadenblockierung und -stlockung verwendet:

<code class="language-csharp">class SizeQueue<T>
{
    private readonly Queue<T> queue = new Queue<T>();
    private readonly int maxSize;
    private bool closing = false; // Flag for graceful closure

    public SizeQueue(int maxSize) { this.maxSize = maxSize; }

    public void Enqueue(T item)
    {
        lock (queue)
        {
            while (queue.Count >= maxSize && !closing) // Check for closure
            {
                Monitor.Wait(queue);
            }
            if (!closing) // Add only if not closing
            {
                queue.Enqueue(item);
                Monitor.PulseAll(queue); // Signal potential dequeue operations
            }
        }
    }

    public T Dequeue()
    {
        lock (queue)
        {
            while (queue.Count == 0 && !closing) // Check for closure
            {
                Monitor.Wait(queue);
            }
            if (!closing) // Dequeue only if not closing
            {
                T item = queue.Dequeue();
                Monitor.PulseAll(queue); // Signal potential enqueue operations
                return item;
            }
            else
            {
                throw new InvalidOperationException("Queue is closed.");
            }
        }
    }

    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();
            Monitor.PulseAll(queue);
            return true;
        }
    }


    public void Close()
    {
        lock (queue)
        {
            closing = true;
            Monitor.PulseAll(queue); // Wake up any waiting threads
        }
    }
}</code>

Dieses erweiterte SizeQueue<T> bietet eine Thread-Safe, die die Warteschlange mit einer Close() -Methode für kontrolliertes Herunterfahren blockiert, Deadlocks verhindert und die anmutige Beendigung des Verzehrs von Fäden sicherstellt. Die TryDequeue -Methode ermöglicht die Überprüfung des Zustands der Warteschlange, bevor versucht wird, zu dequeue.

Das obige ist der detaillierte Inhalt vonWie implementiere ich eine thread-safe Blocking-Warteschlange in .NET?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!