Compréhension approfondie de wait and notify en Java : analyse du mécanisme de synchronisation des threads

Synchronisation des threads en Java : analyse des principes de fonctionnement des méthodes d'attente et de notification

Dans la programmation multithread Java, la synchronisation entre les threads est un concept très important. Dans le développement réel, nous devons souvent contrôler la séquence d'exécution et l'accès aux ressources entre plusieurs threads. Afin de réaliser la synchronisation des threads, Java fournit des méthodes d'attente et de notification.

Les méthodes wait et notify sont deux méthodes de la classe Object. Elles utilisent le mécanisme de surveillance en Java pour assurer la coordination et la communication entre les threads. Lorsqu'un thread attend une certaine condition, il peut appeler la méthode d'attente de l'objet, et le thread entrera dans l'état d'attente et libérera le verrou de l'objet. Lorsque d'autres threads modifient l'état de l'objet, la méthode notify de l'objet peut être appelée pour avertir le thread en attente, lui permettant ainsi de concourir à nouveau pour le verrou et de poursuivre l'exécution. Les principaux principes de fonctionnement des méthodes

wait et notify sont les suivants : La fonction de la méthode

1. wait est de mettre le thread actuel dans un état d'attente jusqu'à ce qu'une certaine condition soit remplie. Avant d'appeler la méthode wait, le thread doit d'abord acquérir le verrou de l'objet. S'il n'est pas acquis, une IllegalMonitorStateException sera levée. Une fois que le thread entre dans l'état d'attente, il libère le verrou de l'objet et entre dans la file d'attente. Le thread en attente ne peut être réveillé que lorsque d'autres threads appellent la méthode notify ou la méthode notifyAll de l'objet correspondant. La fonction de la méthode
2. notify est de réveiller un thread dans la file d'attente afin qu'il puisse se rejouer pour acquérir le verrou et poursuivre l'exécution. S'il y a plusieurs threads dans la file d'attente, le thread qui est réveillé n'est pas défini et dépend de la politique de planification du système d'exploitation. Il convient de noter que la méthode notify ne réveillera qu'un seul thread, tandis que la méthode notifyAll réveillera tous les threads en attente.

Un exemple de code est donné ci-dessous pour démontrer l'utilisation des méthodes wait et notify :

public class WaitNotifyDemo {
    private static final Object lock = new Object();
    private static boolean flag = false;

    public static void main(String[] args) {
        Thread waitThread = new Thread(new WaitTask());
        Thread notifyThread = new Thread(new NotifyTask());

        waitThread.start();

        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        notifyThread.start();
    }

    static class WaitTask implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                while (!flag) {
                    try {
                        System.out.println("等待线程进入等待状态");
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                System.out.println("等待线程被唤醒，继续执行");
            }
        }
    }

    static class NotifyTask implements Runnable {
        @Override
        public void run() {
            synchronized (lock) {
                System.out.println("通知线程唤醒等待线程");
                lock.notify();
                flag = true;
            }
        }
    }
}

Dans l'exemple ci-dessus, waitThread commence à s'exécuter en premier, et lorsqu'il essaie d'entrer dans le bloc synchronisé, puisque la valeur initiale de flag est false , la méthode wait sera appelée pour entrer dans l'état d'attente. Ensuite, notifyThread démarre et se met en veille pendant 2 secondes. Après cela, il acquiert le verrou, définit la valeur de flag sur true et appelle la méthode notify pour réveiller le thread en attente. Finalement, waitThread est réveillé et l'exécution continue à partir de l'endroit après la méthode wait.

Avec cet exemple, nous pouvons mieux comprendre comment fonctionnent les méthodes d'attente et de notification. Ce sont des outils importants pour la synchronisation et la communication entre les threads, résolvant efficacement les problèmes de concurrence et d’accès aux ressources entre les threads. Dans les applications pratiques, une utilisation raisonnable des méthodes d'attente et de notification peut garantir une collaboration fluide entre plusieurs threads.

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!