Apprenez les fonctions et les applications des méthodes objet wait and notify en Java

Comprendre les méthodes objet en Java : le rôle et l'utilisation de wait et notify

En Java, les méthodes objet sont un outil important pour implémenter la programmation simultanée. Parmi elles, wait et notify sont deux méthodes couramment utilisées, utilisées pour implémenter les opérations d'attente et de réveil des threads. Cet article présentera ces deux méthodes en détail et fournira quelques exemples de code spécifiques. La méthode

wait est une méthode définie dans la classe Object. Elle est utilisée pour mettre le thread actuel dans un état d'attente jusqu'à ce que d'autres threads appellent la méthode notify ou notifyAll du même objet pour le réveiller. Avant d'appeler la méthode wait, le thread doit d'abord obtenir le verrouillage du moniteur de l'objet. La méthode wait a deux formes surchargées :

1. wait() : fait attendre le thread actuel jusqu'à ce que d'autres threads le réveillent.
2. wait(long timeout) : fait attendre le thread actuel pendant le nombre de millisecondes spécifié, ou jusqu'à ce qu'un autre thread le réveille.

Ce qui suit est un exemple de code qui utilise la méthode wait pour implémenter le modèle producteur-consommateur :

public class ProducerConsumer {
    private final Object lock = new Object();
    private List<String> buffer = new ArrayList<>();
    private int bufferSize = 10;
    
    public void produce() throws InterruptedException {
        synchronized (lock) {
            // 判断缓冲区是否已满
            while (buffer.size() == bufferSize) {
                lock.wait(); // 等待消费者消费
            }
            // 生产物品到缓冲区
            buffer.add("Item");
            System.out.println("生产者生产一个物品，缓冲区大小：" + buffer.size());
            // 唤醒等待的消费者线程
            lock.notifyAll();
        }
    }
    
    public void consume() throws InterruptedException {
        synchronized (lock) {
            // 判断缓冲区是否为空
            while (buffer.isEmpty()) {
                lock.wait(); // 等待生产者生产
            }
            // 从缓冲区消费物品
            String item = buffer.remove(0);
            System.out.println("消费者消费一个物品，缓冲区大小：" + buffer.size());
            // 唤醒等待的生产者线程
            lock.notifyAll();
        }
    }
}

Dans le code ci-dessus, le producteur utilise la méthode wait pour se mettre dans un état d'attente jusqu'à ce que le tampon soit plein avant de produire ; le consommateur utilise La méthode wait se met en état d'attente jusqu'à ce que le tampon ne soit pas vide avant de consommer. Lorsqu'un producteur produit un élément ou qu'un consommateur consomme un élément, la méthode notifyAll de l'objet est appelée pour réveiller le thread en attente. La méthode

notify est également une méthode définie dans la classe Object. Elle est utilisée pour réveiller un thread en attente du même objet. Contrairement à la méthode notifyAll, la méthode notify ne peut réveiller qu'un seul des threads. Voici un exemple d'utilisation de la méthode notify :

public class ThreadMonitor {
    private final Object lock = new Object();
    
    public void performTask() throws InterruptedException {
        synchronized (lock) {
            System.out.println("线程" + Thread.currentThread().getId() + "开始执行任务");
            lock.wait(); // 等待唤醒
            System.out.println("线程" + Thread.currentThread().getId() + "继续执行任务");
        }
    }
    
    public void wakeUpThread() {
        synchronized (lock) {
            lock.notify(); // 唤醒等待的线程
        }
    }
}

Dans le code ci-dessus, la méthode performTask met le thread dans un état d'attente jusqu'à ce que d'autres threads appellent la méthode wakeUpThread pour le réveiller. La méthode wakeUpThread utilise la méthode notify pour réveiller un thread en attente.

Il convient de noter que lorsque vous utilisez les méthodes wait et notify, vous devez d'abord obtenir le verrouillage du moniteur de l'objet, c'est-à-dire l'utiliser dans un bloc de code synchronisé ou une méthode synchronisée.

Pour résumer, attendre et notifier sont des méthodes importantes en Java pour réaliser la communication inter-thread. Ils peuvent implémenter des opérations d'attente de thread et de réveil, et sont utilisés pour coordonner la séquence d'exécution de plusieurs threads et l'accès aux ressources partagées. Les exemples de code fournis dans cet article peuvent aider les lecteurs à mieux comprendre l'utilisation de ces deux méthodes. En utilisant correctement les méthodes d'attente et de notification, nous pouvons écrire des programmes multithread plus sûrs et plus efficaces.

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!