wait用法java_Java多线程系列之wait

前言

我们知道让线程阻塞除了可以调用sleep方法，join方法还有wait方法，前两个是属于Tread的方法，而wait是属于Object的方法，今天就来聊一聊wait的用法。

先看一看wait的三个重载方法

• 第一个

public final void wait() throws InterruptedException

• 第二个

public final void wait(long timeout) throws InterruptedException

• 第三个

public final void wait(long timeout， int nanos) throws InterruptedException

第一个跟第三个方法最终调用的都是第二个方法，第一个方法相当于调用wait(0),0表示永远不超时。一旦调用的对象的wait方法，那么只有调用对象的notify或者notifyAll才能将其唤醒，或者阻塞时间达到了timeout时间也会自动唤醒。

每一个对象都有一个跟它关联的monitor,只有获取到对象的monitor才能调用对象的wait方法和调用对象的notify和notifyAll方法。也就是说wait，notify，notifyAll都必须在对象的synchronized同步方法里面调用

如果wait没有在对象的synchronized同步块里面执行会抛出

java.lang.IllegalMonitorStateException

• 例如执行以下方法:

private Object lock = new Object();    public void block(){          try {              lock.wait();    } catch (InterruptedException e) {              e.printStackTrace();    }  }

• 抛出异常

Exception in thread "Thread-0" java.lang.IllegalMonitorStateException    at java.base/java.lang.Object.wait(Native Method)    at java.base/java.lang.Object.wait(Object.java:326)    at com.bzl.dp.eqpt.dev.TestWait.block(TestWait.java:28)    at com.bzl.dp.eqpt.dev.TestWait.lambda$main$0(TestWait.java:14)    at java.base/java.lang.Thread.run(Thread.java:835)

使用notify唤醒wait

• 看下面例子执行结果是什么

public static void main(String[] args) {    TestWait tw = new TestWait();    Thread t1 = new Thread(() -> tw.block());  t1.start();    //短暂休眠以便让block先执行    try {          Thread.sleep(10L);    } catch (InterruptedException e) {          e.printStackTrace();    }    tw.release();  }    private Object lock = new Object();    public void block() {      synchronized (lock) {          try {              System.out.println("before wait");              lock.wait();              System.out.println("after wait");          } catch (InterruptedException e) {              e.printStackTrace();          }      }  }    public void release() {      synchronized (lock) {          lock.notify();          System.out.println("after release");      }  }

• 运行结果

before waitafter releaseafter wait

具体流程如下：

首先我们启动了一个新的线程执行了lock的wait方法，然后在主线程去唤醒执行了wait的线程,为了让block方法先执行，这里还短暂的休眠了一会儿

• 1.当t1执行 block 方法的 synchronized 块时,进入lock对象的锁池,由于现在lock的monitor还没有其他线程持有，所有t1抢占了lock的monitor，打印了 before wait ，当执行到 lock.wait() 时，释放了lock的monitor并且进入lock对象的等待池，等待被唤醒
• 2.主线程执行 release 方法,由于t1已经释放了lock的monitor,所以当release执行到 synchronized 块的时候，进去到lock的锁池,并且成功的获取到了lock的monitor,调用 lock.notify() ，这时把t1从等待池里唤醒(如果有多个线程在等待池里，notify只能随机唤醒一个，需要调用notifyAll才能把等待池的所有线程唤醒)，并且进入到lock的锁池，由于release方法还没执行完同步块代码所以主线程还持有lock的monitor，所以t1要等lock的monitor的释放,当主线程打印 after release 退出同步块释放lock的monitor。
• 3.这时t1才从锁池成功的获取到lock的monitor,最后打印 after wait

完整流程图如下:

使用interrupt()方法中断wait

除了使用notify或notifyAll，还可以使用interrupt方法来中断wait,当使用interrupt中断wait时，会抛出InterruptedException异常

代码如下:

public static void main(String[] args) {      TestInterrupt tw = new TestInterrupt();      Thread t1 = new Thread(() -> tw.block());      t1.start();      new Thread(() -> tw.interrupt(t1)).start();  }    private Object lock = new Object();    public void block() {      synchronized (lock) {          try {              System.out.println("before wait");              lock.wait();              System.out.println("after wait");          } catch (InterruptedException e) {              System.out.println("Thread is interrupted");              e.printStackTrace();          }      }  }    public void interrupt(Thread t) {      try {          Thread.sleep(1000L);    } catch (InterruptedException e) {          e.printStackTrace();    }      synchronized (lock) {          t.interrupt();          try {              Thread.sleep(1000L);          } catch (InterruptedException e) {              e.printStackTrace();          }          System.out.println("Interrupt the thread.");      }  }

运行结果：

before waitInterrupt the thread.Thread is interruptedjava.lang.InterruptedException    at java.base/java.lang.Object.wait(Native Method)    at java.base/java.lang.Object.wait(Object.java:326)    at com.bzl.dp.eqpt.dev.TestInterrupt.block(TestInterrupt.java:24)    at com.bzl.dp.eqpt.dev.TestInterrupt.lambda$main$0(TestInterrupt.java:13)    at java.base/java.lang.Thread.run(Thread.java:835)

具体流程如下:

• 1.创建线程t1，执行block方法，t1进去lock的锁池,并且获取lock的monitor，打印 before wait , t1释放lock的monitor，并且进去lock的等待池，等待被唤醒。
• 2.创建新线程，并且在新线程执行 interrupt 方法，入参为t1，新线程休眠1秒，新线程进入lock锁池并且获取lock的monitor，执行t1线程的interrupt方法，把t1线程从等待池唤醒，并且进入lock的锁池，等待获取lock的monitor，因为现在新线程还没有执行完同步块，还持有lock的monitor，所以t1线程还在堵塞状态，当新线程休眠完1秒并且打印 Interrupt the thread 退出同步块,释放monitor。( interrupt方法没有要求一定要在synchronized块里面执行，这里只是演示t1线程被执行interrupt后需要获取monitor才能继续执行，所以这里加了一个synchronized )
• 3.t1在锁池获取到lock的monitor，因为 t1 使被调用 interrupt 唤醒的，所以收到一个 InterruptedException 异常，并且 interrupt 状态会被清空，这时异常被捕获，跳过打印 after wait ，最后执行 Thread is interrupted

完成流程图如下: