Comment utiliser correctement les méthodes objet attendre et notifier en Java

Comment utiliser correctement les méthodes objet en Java : attendre et notifier

En Java, attendre et notifier sont des méthodes importantes utilisées pour réaliser une collaboration entre multi-threads. L'utilisation correcte de ces deux méthodes peut éviter les problèmes multithread tels que les conditions de concurrence et les blocages, et garantir la sécurité et l'efficacité du programme. Cet article explique comment utiliser correctement les méthodes objet wait et notify en Java et fournit des exemples de code spécifiques.

1. Les principes et fonctions de base d'attendre et de notifier

Avant de comprendre comment utiliser correctement attendre et notifier, vous devez comprendre leurs principes et fonctions de base.

1. wait : mettez le thread actuel dans un état d'attente jusqu'à ce que d'autres threads le réveillent via la méthode notify ou notifyAll. L'utilisation de la méthode wait peut effectivement libérer le verrou de l'objet et bloquer le thread actuel, ce qui l'oblige à suspendre son exécution.
2. notifier : Réveille un fil en attente sur l'objet. S'il y a plusieurs threads en attente, notify ne réveillera qu'un seul thread de manière aléatoire et le thread spécifique à réveiller est incertain.
3. notifyAll : Réveillez tous les threads en attente sur cet objet. Utilisez la méthode notifyAll pour réveiller tous les threads en attente, mais le thread à réveiller dépend du planificateur de threads.

2. Étapes pour utiliser correctement wait and notify

Pour utiliser wait and notify correctement, vous devez suivre les étapes suivantes :

1. Verrouillage : lors de l'utilisation de wait and notify, vous devez d'abord obtenir le verrouillage de l'objet. Vous pouvez utiliser le mot-clé synchronisé pour verrouiller ou utiliser l'objet Lock pour verrouiller.
2. Appelez la méthode wait : avant d'entrer dans la section critique, appelez la méthode wait de l'objet lock pour mettre le thread actuel dans un état d'attente.
3. Jugement conditionnel : Avant d'entrer dans la section critique, les conditions des ressources partagées doivent d'abord être vérifiées. Si la condition n’est pas remplie, vous devez continuer à attendre jusqu’à ce qu’elle soit remplie.
4. Relâcher le verrou : après avoir appelé la méthode d'attente, le thread actuel libérera le verrou de l'objet, permettant à d'autres threads d'entrer dans la section critique pour exploiter les ressources partagées.
5. Appelez la méthode notify ou notifyAll : lorsque les conditions sont remplies, vous pouvez appeler la méthode notify ou notifyAll de l'objet de verrouillage pour réveiller le thread en attente.
6. Relock : Le fil éveillé retrouvera le verrouillage de l'objet et continuera à concourir pour l'exécution.

3. Exemples de code spécifiques

Les exemples de code suivants montrent comment utiliser correctement wait et notify pour réaliser une collaboration entre deux threads. Un thread est chargé d'attendre d'être réveillé et l'autre thread est responsable du réveil.

public class WaitNotifyExample {
    private static final Object lock = new Object();
    private static boolean isReady = false;

    public static void main(String[] args) {
        Thread waitingThread = new Thread(() -> {
            synchronized (lock) {
                while (!isReady) {
                    try {
                        System.out.println("等待中...");
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("等待结束！");
            }
        });

        Thread notifyingThread = new Thread(() -> {
            synchronized (lock) {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("唤醒等待的线程...");
                isReady = true;
                lock.notify();
            }
        });

        waitingThread.start();
        notifyingThread.start();
    }
}

Exécutez le code ci-dessus, vous pouvez voir que le thread en attente entrera dans l'état d'attente et poursuivra son exécution après avoir été réveillé.

Dans cet exemple, nous utilisons une variable booléenne partagée isReady pour représenter la condition d'attente. Le thread en attente vérifiera isReady avant d'entrer dans la section critique. Si la condition n'est pas remplie, la méthode wait sera appelée pour entrer dans l'état d'attente. Une fois que le thread de réveil remplit la condition, il modifiera la valeur de isReady et appellera la méthode notify pour réveiller le thread en attente.

Il convient de noter que lors de l'utilisation de wait et notify, vous devez vous assurer que le thread acquiert le verrou du même objet. Sinon, le thread ne peut pas entrer correctement dans l'état d'attente ou être réveillé.

Résumé

L'utilisation des méthodes wait et notify peut réaliser une collaboration entre plusieurs threads et garantir la sécurité et l'efficacité du programme. Lorsque vous utilisez ces deux méthodes, vous devez suivre les étapes correctes, notamment le verrouillage, l'appel de la méthode wait, la vérification des conditions, la libération du verrou, l'appel de la méthode notify, etc. En utilisant rationnellement les méthodes d'attente et de notification, nous pouvons éviter les problèmes de multithread et améliorer la fiabilité et la maintenabilité du programme.

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!