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 wait
after release
after 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 wait
Interrupt the thread.
Thread is interrupted
java.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

完成流程图如下: