Wie gestalte ich eine thread-safe Blockierwarteschlange in .NET?

Konstruieren Sie eine Thread -Sicherheitsblockierungswarteschlange im .NET

In der Umgebung mit mehreren Threads ist, wenn mehrere Threads dieselbe Warteschlange betreiben, effizientes Warteschlangenmanagement von wesentlicher Bedeutung. In diesem Artikel wird erläutert, wie eine blockierende Warteschlange im .NET erstellt wird, um diese Nachfrage zu befriedigen.

Die Einschränkungen der vorhandenen Implementierung

Das in der Frage bereitgestellte Codefragment zeigt die grundlegende Implementierung einer blockierenden Warteschlange. Es fehlen jedoch geeignete Synchronisationsmechanismen und kann zu Problemen mit Thread -Sicherheit führen.

Verbesserungsmethode

Um die Einschränkungen der ursprünglichen Implementierung zu lösen, betrachten Sie bitte die folgende verbesserte Version:

In dieser verbesserten Version, der Vorgangsvorgang der Satzschutzwarteschlange, um die Sicherheit der Gewinne zu gewährleisten.

<code class="language-csharp">class SizeQueue<T>
{
    private readonly Queue<T> queue = new Queue<T>();
    private readonly int maxSize;
    private bool closing; // 添加关闭标志

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

    public void Enqueue(T item)
    {
        lock (queue)
        {
            while (queue.Count >= maxSize && !closing) // 检查关闭标志
            {
                Monitor.Wait(queue);
            }
            if(closing) return; // 如果队列已关闭，则直接返回
            queue.Enqueue(item);
            if (queue.Count == 1)
            {
                Monitor.PulseAll(queue);
            }
        }
    }

    public T Dequeue()
    {
        lock (queue)
        {
            while (queue.Count == 0 && !closing) // 检查关闭标志
            {
                Monitor.Wait(queue);
            }
            if(closing && queue.Count == 0) throw new InvalidOperationException("Queue is closed and empty."); // 队列关闭且为空
            T item = queue.Dequeue();
            if (queue.Count == maxSize - 1)
            {
                Monitor.PulseAll(queue);
            }
            return item;
        }
    }

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

Klasse wird verwendet, um den Blockierungsfaden gemäß dem Status der Warteschlange zu blockieren und anzuheben. Darüber hinaus werden die Methoden Logo und

dem eleganten Verschluss der Warteschlange hinzugefügt, und die lock -Methode wird verwendet, um die Warteschlange als leer zu handhaben. Monitor closing Weitere Überlegung Close() TryDequeue() Für tatsächliche Anwendungen muss möglicherweise die Situation umgehen, in der die Warteschlange geschlossen ist oder die Notwendigkeit einer Eleganz benötigt wird. Aus diesem Grund kann der Code wie folgt geändert werden (wie oben gezeigt).

Diese erweiterten Funktionen ermöglichen den Lesen von Thread in geordneter Weise, wenn die Warteschlange geschlossen ist. Der verbesserte Code erhöht die Überprüfung des Schlangenverschlusses und verarbeitet die Situation des Schlangenverschlusses und leer, wodurch Anomalien vermieden werden.

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