Quelle est la différence entre les méthodes sleep et wait en Java ?

1. La différence entre les méthodes sleep et wait

• La différence fondamentale : sleep est une méthode de la classe Thread et n'entrera pas immédiatement dans l'état d'exécution, wait est une méthode de la classe Object, une fois qu'elle l'objet appelle la méthode wait, les méthodes notify() et notifyAll() doivent être utilisées pour réveiller le processus

• Libérer le verrou de synchronisation : sleep libérera le processeur, mais sleep ne libérera pas les ressources du verrou de synchronisation, wait le fera libérer les ressources de verrouillage de synchronisation

• Portée d'utilisation : sleep peut être utilisé n'importe où, mais wait ne peut être utilisé que dans des méthodes de synchronisation synchronisées ou des blocs de code

• Gestion des exceptions : sleep doit intercepter les exceptions, mais wait n'a pas besoin de le faire attraper les exceptions

2. méthode d'attente

• Faire attendre le thread en cours d'exécution du code (Mettre le thread dans la file d'attente)

• Libérer le verrou actuel

• Être réveillé lorsque certaines conditions sont remplies. rencontré, et essayez à nouveau d'acquérir le verrou

• wait doit être utilisé avec synchronisé. L'utilisation de wait sans synchronisé lancera directement une exception

Utilisation de la méthode wait

wait méthode

/**
 * wait的使用
 */
public class WaitDemo1 {
    public static void main(String[] args) {
        Object lock = new Object();
        Thread t1 = new Thread(() -> {
            System.out.println("线程1开始执行");
            try {
                synchronized (lock) {
                    System.out.println("线程1调用wait方法....");
                    // 无限期的等待状态
                    lock.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("线程1执行完成");
        }, "线程1");
        t1.start();
    }
}

Avec le paramètre wait thread. et aucun paramètre de thread d'attente

/**
 * 有参wait线程和无参wait线程
 */
public class WaitDemo2 {
    public static void main(String[] args) {
        Object lock1 = new Object();
        Object lock2 = new Object();
        Thread t1 = new Thread(()->{
            System.out.println("线程1开始执行");
            synchronized (lock1){
                try {
                    lock1.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程1执行完成");
            }
        },"无参wait线程");
        t1.start();
        Thread t2 = new Thread(()->{
            System.out.println("线程2开始执行");
            synchronized (lock2){
                try {
                    lock2.wait(60*60*1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("线程2执行完成");
            }
        },"有参wait线程");
        t2.start();
    }
}

Conditions d'attente pour mettre fin à l'attente

①D'autres threads appellent la méthode notify de l'objet

②Le délai d'attente expire (la méthode wait fournit une version avec un paramètre timeout pour spécifier le temps d'attente. ).

③D'autres threads appellent la méthode interrompue du thread en attente, provoquant une attente. appelée dans une méthode synchronisée ou un bloc synchronisé. Cette méthode est utilisée pour avertir ceux qui peuvent. D'autres threads attendent le verrouillage de l'objet

S'il y a plusieurs threads en attente, sélectionnez au hasard un thread dans l'état d'attente

1. Après la méthode notify(), le thread actuel ne libérera pas le verrou d'objet immédiatement et attendra que le thread exécutant la méthode notify() termine l'exécution du programme, c'est-à-dire que le verrou d'objet sera libéré après la sortie du synchronisé bloc de code

2. L'utilisation de la méthode notify

   /**
    * wait的使用， 如果有多个线程等待，随机挑选一个wait状态的线程
    */
   public class WaitNotifyDemo {
       public static void main(String[] args) {
           Object lock1 = new Object();
           Object lock2 = new Object();
           Thread t1 = new Thread(()->{
               System.out.println("线程1开始执行");
               try {
                   synchronized (lock1) {
                       System.out.println("线程1调用wait方法");
                       lock1.wait();
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("线程1执行完成");
           },"线程1");
           Thread t2 = new Thread(()->{
               System.out.println("线程2开始执行");
               try {
                   synchronized (lock1) {
                       System.out.println("线程2调用wait方法");
                       lock1.wait();
                   }
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("线程2执行完成");
           },"线程2");
           t1.start();
           t2.start();
           // 唤醒 lock1 对象上休眠的线程的（随机唤醒一个）
           Thread t3 = new Thread(()->{
               try {
                   Thread.sleep(1500);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               System.out.println("线程3开始执行");
               synchronized (lock1){
                   //发出唤醒通知
                   System.out.println("执行了唤醒");
                   try {
                       Thread.sleep(2000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
               }
           },"线程3");
           t3.start();
       }
   }

La méthode notifyAll peut réveiller tous les threads en attente en même temps

3. L'utilisation de la méthode notifyAll

   /**
    * notifyAll-唤醒所有线程
    */
   public class WaitNotifyAll {
       public static void main(String[] args) {
           Object lock = new Object();
   
           new Thread(() -> {
               System.out.println("线程1：开始执行");
               synchronized (lock) {
                   try {
                       lock.wait();
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println("线程1：执行完成");
               }
           }, "无参wait线程").start();
   
           new Thread(() -> {
               synchronized (lock) {
                   System.out.println("线程2：开始执行 |" + LocalDateTime.now());
                   try {
                       lock.wait(60 * 60 * 60 * 1000);
                   } catch (InterruptedException e) {
                       e.printStackTrace();
                   }
                   System.out.println("线程2：执行完成 | " + LocalDateTime.now());
               }
           }, "有参wait线程").start();
   
           new Thread(() -> {
               try {
                   TimeUnit.SECONDS.sleep(1);
               } catch (InterruptedException e) {
                   e.printStackTrace();
               }
               synchronized (lock) {
                   System.out.println("唤醒所有线程");
                   lock.notifyAll();
               }
           }).start();
       }
   }

La différence entre les méthodes notify et notifyAll

Quand vous appelez notify, un seul thread en attente sera réveillé et il n'a aucune garantie quel thread sera réveillé, cela dépend du planificateur de threads.

appelez la méthode notifyAll, puis tous les threads en attente du verrou seront réveillés, mais avant d'exécuter le reste du code, tous les threads réveillés se disputeront le verrou, c'est pourquoi wait est appelé sur la boucle, car si plusieurs threads sont réveillés, alors le thread qui acquerra le verrou s'exécutera en premier, il peut réinitialiser la condition d'attente, ce qui forcera les threads suivants à attendre.

1. Donc, la principale différence entre notify et notifyAll est que notify() ne réveillera qu'un seul thread tandis que la méthode notifyAll réveillera tous les 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!