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 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

完成流程图如下: