Wie implementieren die Java-Methoden „wait()' und „notify()' eine Blockierungswarteschlange?

wait() und notify() in Java: Ein einfaches Szenario mit Warteschlange

In Java sind wait() und notify() Methoden bieten einen Mechanismus für die Thread-Synchronisierung. Lassen Sie uns ein einfaches Szenario untersuchen, in dem diese Methoden zum Implementieren einer Blockierungswarteschlange verwendet werden können.

Implementierung einer Blockierungswarteschlange

Eine Blockierungswarteschlange ist eine Warteschlangendatenstruktur, die Threads blockiert, wenn Versuchen, bestimmte Vorgänge auszuführen, wenn bestimmte Bedingungen nicht erfüllt sind. In unserer Implementierung werden wir die Methoden put() und take() implementieren, die blockieren, wenn die Warteschlange jeweils voll oder leer ist.

public class BlockingQueue<T> {

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

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

    // Blocks if the queue is full (no space to insert)
    public synchronized void put(T element) throws InterruptedException {
        while (queue.size() == capacity) {
            wait();
        }

        queue.add(element);
        notifyAll();
    }

    // Blocks if the queue is empty (nothing to remove)
    public synchronized T take() throws InterruptedException {
        while (queue.isEmpty()) {
            wait();
        }

        T item = queue.remove();
        notifyAll();
        return item;
    }
}

Verwendung

Sehen wir uns nun an, wie diese Blockierungswarteschlange verwendet wird.

BlockingQueue<Integer> queue = new BlockingQueue<>(10);

// Producer thread: adds elements to the queue
new Thread(() -> {
    for (int i = 0; i < 15; i++) {
        try {
            queue.put(i);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}).start();

// Consumer thread: retrieves elements from the queue
new Thread(() -> {
    for (int i = 0; i < 15; i++) {
        try {
            System.out.println(queue.take());
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}).start();

In diesem Beispiel fügt der Produzententhread Elemente zur Warteschlange hinzu und blockiert, wenn diese blockiert wird erreicht die Kapazitätsgrenze. Der Verbraucherthread ruft Elemente ab und blockiert, wenn die Warteschlange leer ist.

Wichtige Überlegungen

• Synchronisierte Blöcke verwenden: wait() und notify() müssen innerhalb synchronisierter Blöcke verwendet werden, um Thread-Sicherheit zu gewährleisten und verpasste Signale zu verhindern.
• Verwenden Sie eine Weile Schleife:Verwenden Sie eine While-Schleife, um Bedingungen aufgrund unerwünschter Aktivierungen zu überprüfen (wenn ein Thread ohne Benachrichtigung erneut aktiviert wird).
• Berücksichtigen Sie die Java 1.5-Parallelitätsbibliothek:Java 1.5 führte eine Parallelitätsbibliothek mit Abstraktionen höherer Ebenen ein (z. B. Sperre und Bedingung). Es bietet einen saubereren und vielseitigeren Ansatz.

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