Comment les méthodes Java `wait()` et `notify()` peuvent-elles être utilisées pour implémenter une file d'attente de blocage ?-javaDidacticiel-php.cn

Comment les méthodes Java `wait()` et `notify()` peuvent-elles être utilisées pour implémenter une file d'attente de blocage ?

Barbara Streisand

Libérer： 2024-11-23 09:42:31

original

718 Les gens l'ont consulté

How Can Java's `wait()` and `notify()` Methods Be Used to Implement a Blocking Queue?

Utilisation de Wait() et Notify() en Java : un scénario avec des files d'attente

Question :

Pouvez-vous fournir une présentation complète de la façon d'implémenter les méthodes wait() et notify() avec un File d'attente ?

Réponse :

Principe d'attente() et Notify()

Wait() et notify() activez la coordination des threads en faisant en sorte que les threads attendent que des conditions spécifiques soient remplies avant de continuer. Dans ce cas, nous souhaitons créer une file d'attente de blocage qui applique les limitations de capacité.

Mise en œuvre

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

Copier après la connexion

Comment ça marche

Méthode Put() : Si la file d'attente est pleine, le thread actuel attend jusqu'à ce qu'il reçoive une notification indiquant que de l'espace est disponible.
Méthode Take() : Si la file d'attente est vide, le thread actuel attend de recevoir une notification indiquant qu'un élément est disponible.

Remarque : Assurez-vous que les appels wait() et notify() sont synchronisés sur le même objet et placés dans une boucle while pour gérer réveils parasites.

Fonctionnalités concurrentes de Java 1.5

Java 1.5 a introduit le package java.util.concurrent, fournissant des abstractions de niveau supérieur pour la coordination des threads. Voici une version mise à jour de l'exemple :

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

Copier après la connexion

Cette approche utilise des verrous et des conditions pour améliorer la coordination des threads.

Considérez l'interface BlockingQueue

Si vous avez besoin d'une file d'attente de blocage, envisagez d'utiliser une implémentation de l'interface Java BlockingQueue, qui fournit une implémentation standard avec thread-safe et contrôle de capacité. opérations.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!