Was ist der Unterschied zwischen Sleep- und Wait-Methoden in Java?

1. Der Unterschied zwischen Sleep- und Wait-Methoden

• Der grundlegende Unterschied: Sleep ist eine Methode in der Thread-Klasse und wechselt nicht sofort in den laufenden Zustand. Wait ist eine Methode in der Object-Klasse, sobald ein Das Objekt ruft die Methode „wait“ auf. Zum Aufwecken des Prozesses müssen die Methoden „notify()“ und „notifyAll()“ verwendet werden Geben Sie die Ressourcen für die Synchronisierungssperre frei.

• Verwendungsbereich: Sleep kann überall verwendet werden, Wait kann jedoch nur in synchronisierten Synchronisierungsmethoden oder Codeblöcken verwendet werden. Ausnahmebehandlung: Sleep muss Ausnahmen abfangen, Wait muss jedoch nicht Ausnahmen abfangen

• 2. Wartemethode

• Den Thread, der den Code gerade ausführt, warten lassen (den Thread in die Warteschlange stellen)

Die aktuelle Sperre aufheben

• Werden, wenn bestimmte Bedingungen erfüllt sind erfüllt, und versuchen Sie erneut, die Sperre zu erhalten.

• Die Verwendung von „Wait“ ohne „Synchronized“ führt direkt zu einer Ausnahme und kein Parameter Wartethread

  /**
   * 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();
      }
  }

Bedingungen für das Warten, um das Warten zu beenden

• ①Andere Threads rufen die Benachrichtigungsmethode des Objekts auf

②Die Wartewartezeit läuft ab (die Wartemethode stellt eine Version mit einem Timeout-Parameter bereit, um die Wartezeit anzugeben ).

• ③Andere Threads rufen die unterbrochene Methode des wartenden Threads auf, was zu Wait Throws InterruptedException führt Diese Methode wird in einer synchronisierten Methode oder einem synchronisierten Block aufgerufen, um diejenigen zu benachrichtigen, die möglicherweise auf die Objektsperre des Objekts warten.

Wenn mehrere Threads warten, wählen Sie zufällig einen Thread im Wartezustand aus

Nach der Methode notify () gibt der aktuelle Thread die Objektsperre nicht sofort frei und wartet, bis der Thread, der die Methode notify () ausführt, die Ausführung des Programms beendet, dh die Objektsperre wird nach dem Beenden der Synchronisierung aufgehoben Codeblock

Die Verwendung der Notify-Methode

/**
 * 有参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();
    }
}

Die NotifyAll-Methode kann alle wartenden Threads gleichzeitig aufwecken

Die Verwendung der NotifyAll-Methode

/**
 * 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();
    }
}

Der Unterschied zwischen Notify- und NotifyAll-Methoden

When Wenn Sie notify aufrufen, wird nur ein wartender Thread geweckt und es gibt keine Garantie, welcher Thread geweckt wird. Dies hängt vom Thread-Scheduler ab.

1. Rufen Sie die notifyAll-Methode auf, dann werden alle Threads, die auf die Sperre warten, aufgeweckt, aber bevor der Rest des Codes ausgeführt wird, konkurrieren alle aufgeweckten Threads um die Sperre, deshalb wird in der Schleife „wait“ aufgerufen. Denn wenn mehrere Threads aktiviert werden, wird der Thread, der die Sperre erhält, zuerst ausgeführt. Möglicherweise wird die Wartebedingung zurückgesetzt, wodurch nachfolgende Threads zum Warten gezwungen werden.

2. Der Hauptunterschied zwischen notify und notifyAll besteht also darin, dass notify() nur einen Thread aufweckt, während die Methode notifyAll alle Threads aufweckt.

Das obige ist der detaillierte Inhalt vonWas ist der Unterschied zwischen Sleep- und Wait-Methoden in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!