Wie können die Java-Methoden „wait()' und „notify()' verwendet werden, um eine Blockierungswarteschlange zu implementieren?

Wait() und Notify() in Java verwenden: Ein Szenario mit Warteschlangen

Frage:

Können Sie eine umfassende Anleitung zur Implementierung der Methoden wait() und notify() mit a bereitstellen? Warteschlange?

Antwort:

Prinzip von Wait() und Notify()

Wait() und notify() Aktivieren Sie die Thread-Koordination, indem Sie Threads warten lassen, bis bestimmte Bedingungen erfüllt sind, bevor sie fortfahren. In diesem Fall sind wir daran interessiert, eine Blockierungswarteschlange zu erstellen, die Kapazitätsbeschränkungen durchsetzt.

Implementierung

public class BlockingQueue<T> {

    private Queue<T> queue = new LinkedList<>();
    private int capacity;

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    public synchronized void put(T element) throws InterruptedException {
        while (queue.size() == capacity) {
            wait();
        }

        queue.add(element);
        notify(); // Notify waiting threads
    }

    public synchronized T take() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();
        }

        T item = queue.remove();
        notify(); // Notify waiting threads
        return item;
    }
}

Wie es funktioniert

• Put()-Methode: Wenn die Warteschlange voll ist, wird der aktuelle Thread angezeigt wartet, bis er eine Benachrichtigung erhält, dass Platz verfügbar ist.
• Take()-Methode: Wenn die Warteschlange leer ist, wartet der aktuelle Thread, bis er eine Benachrichtigung erhält, dass ein Element verfügbar ist.

Hinweis: Stellen Sie sicher, dass die Aufrufe „wait()“ und „notify()“ auf demselben Objekt synchronisiert und in einer While-Schleife platziert werden, um Störungen zu behandeln Weckrufe.

Java 1.5 Concurrent Features

Java 1.5 führte das Paket java.util.concurrent ein, das Abstraktionen auf höherer Ebene für die Thread-Koordination bereitstellt. Hier ist eine aktualisierte Version des Beispiels:

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class BlockingQueue<T> {

    private Queue<T> queue = new LinkedList<>();
    private int capacity;
    private Lock lock = new ReentrantLock();
    private Condition notFull = lock.newCondition();
    private Condition notEmpty = lock.newCondition();

    public BlockingQueue(int capacity) {
        this.capacity = capacity;
    }

    public void put(T element) throws InterruptedException {
        lock.lock();
        try {
            while (queue.size() == capacity) {
                notFull.await();
            }

            queue.add(element);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public T take() throws InterruptedException {
        lock.lock();
        try {
            while (queue.isEmpty()) {
                notEmpty.await();
            }

            T item = queue.remove();
            notFull.signal();
            return item;
        } finally {
            lock.unlock();
        }
    }
}

Dieser Ansatz verwendet Sperren und Bedingungen für eine verbesserte Thread-Koordination.

Bedenken Sie die BlockingQueue-Schnittstelle

Wenn Sie eine Blockierungswarteschlange benötigen, sollten Sie die Verwendung einer Implementierung der Java-BlockingQueue-Schnittstelle in Betracht ziehen, die eine Standardimplementierung mit Thread-Sicherheit und Kapazitätskontrolle bereitstellt Operationen.

Das obige ist der detaillierte Inhalt vonWie können die Java-Methoden „wait()' und „notify()' verwendet werden, um eine Blockierungswarteschlange zu implementieren?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!