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

Verwenden von wait() und notify() zum Implementieren einer Blockierungswarteschlange

Einführung

In der Multithread-Programmierung sind es wait() und notify() Wird für die Thread-Synchronisation verwendet. In diesem Artikel wird erklärt, wie Sie mit wait() und notify() eine Blockierungswarteschlange implementieren, eine Datenstruktur, die es Threads ermöglicht, zu blockieren, bis ein Element verfügbar ist oder Platz frei wird.

Implementieren einer Blockierungswarteschlange mit wait( ) und notify()

Bedingungen für die Sperrung:

• put() Methode: Blockiert, bis freier Platz in der Warteschlange ist.
• take()-Methode: Blockiert, bis ein Element in der Warteschlange verfügbar ist.

Java-Code:

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(); // notifyAll() for multiple producer/consumer threads
    }

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

        T item = queue.remove();
        notify(); // notifyAll() for multiple producer/consumer threads
        return item;
    }
}

Überlegungen bei der Verwendung von wait() und notify()

• Synchronisierter Code: Rufen Sie wait() und notify() innerhalb einer synchronisierten Methode oder eines synchronisierten Blocks auf.
• While-Schleifen: Verwenden Sie while-Schleifen anstelle von if-Anweisungen, um Bedingungen aufgrund falscher Aktivierungen zu überprüfen.

Java 1.5 Parallelitätsbibliothek

Java 1.5 führte eine Parallelitätsbibliothek ein, die Abstraktionen auf höherer Ebene bereitstellt:

Modifizierte Blockierungswarteschlangenimplementierung:

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

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