Analyse approfondie des méthodes objet en Java : attendre et notifier

Méthodes objet en Java : explication détaillée de wait and notify

En Java, les méthodes objet wait et notify sont des outils importants pour la collaboration et la communication entre les threads. Ils aident les threads à attendre ou à réveiller l'exécution d'autres threads au bon moment. Cet article présentera en détail l’utilisation des méthodes d’attente et de notification et fournira des exemples de code spécifiques.

1. Utilisation de la méthode wait

La méthode wait est utilisée pour mettre le thread actuel dans un état d'attente jusqu'à ce que d'autres threads appellent la méthode notify sur le même objet, ou que la méthode notifyAll le réveille. La méthode wait a les formes suivantes :

1. void wait() : fait attendre le thread actuel jusqu'à ce que les autres threads se réveillent.
2. void wait(long timeout) : fait attendre le thread actuel pendant le nombre de millisecondes spécifié ou jusqu'à ce que les autres threads se réveillent.
3. void wait(long timeout, int nanos) : oblige le thread actuel à attendre le nombre spécifié de millisecondes plus le nombre spécifié de nanosecondes, ou jusqu'à ce que les autres threads se réveillent.

Lors de l'utilisation de la méthode wait, celle-ci doit être incluse dans un bloc de code synchronisé pour assurer le verrouillage de l'objet. Voici un exemple classique :

public class WaitNotifyExample {
    private boolean flag = false;
    
    public synchronized void waitForFlag() {
        try {
            while (!flag) {
                wait(); // 当前线程等待
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 执行其他操作
    }
    
    public synchronized void setFlag() {
        flag = true;
        notify(); // 唤醒正在等待的线程
    }
}

Dans l'exemple ci-dessus, après avoir appelé la méthode waitForFlag, le thread entrera dans l'état d'attente jusqu'à ce que d'autres threads appellent la méthode setFlag pour le réveiller.

2. Utilisation de la méthode notify

La méthode notify est utilisée pour réveiller le thread en attente. Il sélectionnera au hasard un thread à réveiller. Si plusieurs threads sont en attente, un seul d'entre eux pourra être réveillé. La méthode notify est utilisée sous la forme suivante :

public class NotifyExample {
    public synchronized void waitForNotify() {
        try {
            wait(); // 当前线程等待
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 执行其他操作
    }
    
    public synchronized void notifyThread() {
        notify(); // 唤醒一个等待的线程
    }
}

Dans l'exemple ci-dessus, le thread qui appelle la méthode waitForNotify entrera dans l'état d'attente jusqu'à ce que d'autres threads appellent la méthode notifyThread pour le réveiller.

3. Utilisez wait and notify pour réaliser une collaboration inter-thread

Les méthodes wait et notify sont souvent utilisées dans des scénarios de collaboration multi-thread tels que le modèle producteur-consommateur. Voici un exemple simple producteur-consommateur :

public class ProducerConsumerExample {
    private LinkedList<Integer> buffer = new LinkedList<>();
    private final int MAX_SIZE = 10;
    
    public synchronized void produce() {
        while (buffer.size() == MAX_SIZE) {
            try {
                wait(); // 缓冲区已满，生产者线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        buffer.add(1);
        notifyAll(); // 唤醒等待的消费者线程
    }
    
    public synchronized void consume() {
        while (buffer.size() == 0) {
            try {
                wait(); // 缓冲区为空，消费者线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        buffer.removeFirst();
        notifyAll(); // 唤醒等待的生产者线程
    }
}

Dans l'exemple ci-dessus, lorsque le tampon est plein, le thread producteur entre dans un état d'attente jusqu'à ce que le thread consommateur consomme les éléments du tampon et réveille la production ou le thread. Lorsque le tampon est vide, le thread consommateur entrera dans l'état d'attente jusqu'à ce que le thread producteur produise de nouveaux éléments et réveille le thread consommateur.

Résumé : Les méthodes wait et notify sont des outils importants pour la collaboration et la communication entre threads en Java. Ils jouent un rôle clé dans la programmation multithread. Grâce à une utilisation raisonnable des méthodes d'attente et de notification, une collaboration et une communication élégantes entre les threads peuvent être obtenues.

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!