线程的通知与等待

Java中的Object类是所有类的父类,鉴于继承机制,Java把所有的类都需的方法放在了Object类里面,其中就包含要说的通知与等待。

1.wait()方法

当一个线程调用一个共享变量的wait()方法时,该调用线程会被阻塞挂起,直到发生下面几件事情之一才返回。

​ 1.其他线程调用了该共享对象的 notify() *或者 *notifyAll() 方法。

​ 2.其他线程调用了该线程的 interrupt() 方法,该线程抛出 InterruptedException 异常返回

另外需要注意的是,如果调用 wait() 方法的线程没有事先获取该对象的监视器锁,则调用wait()方法时调用线程会抛出 *IllegalMonitorStateException *异常。

那么一个线程如何才能获取一个共享变量的监视器锁呢?

​ 1.执行synchronized同步代码块时使用该共享变量作为参数。

1
2
3
synchronized(共享变量){
// doSomething
}

​ 2.调用该共享变量的方法,并且该方法使用了 synchronized 修饰。

1
2
3
synchronized void method(int a, int b){
// doSomething
}

另外需要注意的时,一个线程可以从挂起状态变为可以运行的状态(也就是被唤醒),即使该线程没有被其他线程调用notify(), notifyAll() 方法进行通知,或者被中断,或者等待超时。也就是所谓的虚假唤醒。

虽然虚假唤醒在应用实践中很少发生,但要防患于未然,做法就是不停地去测试该线程被唤醒状态的条件是否满足,不满足则继续等待,也就是说在一个循环中调用wait()方法进行防范。退出循环的条件就是满足了唤醒该线程的条件。

1
2
3
4
5
synchronized (obj) {
while(条件不满足){
obj.wait();
}
}

如上代码呢也是经典的调用共享变量wait()方法的实例,首先通过同步块获取obj上面的监视器锁,然后再while 循环内调用obj的wait()方法。

下面从一个简单的生产者和消费者例子来加深下理解。如下面代码所示,其中queue为共享变量,生产者线程在调用queue的wait()方法前,使用synchronized关键字拿到了该共享变量queue的监视器锁,所以调用wait()方法不会抛出 IllegalMonitorStateException 异常。如果当前队列没有空闲容量则会调用wait()方法挂起当前线程,这里使用循环是为了避免上面说的虚假唤醒。假如当前线程被虚假唤醒了,但是队列还是没有空余的容量,那么当前线程还是会调用wait()方法把自己挂起。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class ObjectMethodTest {

Queue<String> queue = new LinkedList<String>();

int MAX_SIZE = 1; // 假设队列长度只有1 , 只能存放一条数据


public void produce(){
synchronized (queue){

// 队列满则等待队列空间
while (queue.size() == MAX_SIZE) {
// 挂起当前线程,并释放通过同步块获取的queue上的锁,让消费者线程可以获取该锁,然后获取队列里面的元素。
try {
queue.wait();
System.out.println("-----等待消费----");
} catch (InterruptedException e) {
e.printStackTrace();
}
}


queue.add("hahaha");
queue.notifyAll();
}
}

public void consume(){
synchronized (queue) {

while (queue.size() == 0) {
// 挂起当前线程,并释放通过同步块获取的queue上的锁,让消费者线程可以获取该锁,然后获取队列里面的元素。
try {
queue.wait();
System.out.println("-----等待生产-----");
} catch (InterruptedException e) {
e.printStackTrace();
}
}

// 消费元素, 并通知唤醒生产者
System.out.println("消费成功:" + queue.poll());
queue.notifyAll();
}
}

public static void main(String[] args) {


ObjectMethodTest objectMethodTest = new ObjectMethodTest();

// 10 个生产线程
for (int i = 0; i < 10; i++) {
new Thread(objectMethodTest::produce).start();
}

// 10 个消费线程
for (int i = 0; i < 10; i++) {
new Thread(objectMethodTest::consume).start();
}
}
}

image-20200111212730839

在如上代码中,假如生产者线程A首先通过synchronized获取到了queue上的锁,那么后续所有企图生产的线程和消费的线程 都将会在获取该监视器锁的地方被阻塞挂起。线程A获取锁后发现队列已满会调用wait()方法阻塞挂起自己,然后就会释放掉获取到的queue上的锁,防止发生死锁。

另外需要注意的是,当前线程调用共享变量的wait()方法后指挥释放当前共享变量上的锁,如果当前线程还持有其他共享变量的锁,则这些锁是不会被释放的,接下来看例子。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
public class WaitTest {
private static volatile Object resourceA = new Object();
private static volatile Object resourceB = new Object();

public static void main(String[] args) throws InterruptedException {

// 创建线程
Thread threadA = new Thread(() -> {

try {
synchronized (resourceA) {
System.out.println("threadA 获取到resourceA的锁");

synchronized (resourceB){
System.out.println("threadA 获取到 resourceB的锁");

System.out.println("threadA 释放掉 resourceA的锁");
resourceA.wait();
}
}
}catch (Exception ex) {
ex.printStackTrace();
}
});


// 创建线程
Thread threadB = new Thread(() -> {

try {
Thread.sleep(1000);

synchronized (resourceA) {
System.out.println("threadB 获取到resourceA的锁");

System.out.println("threadB 尝试获取resourceB的锁*****");
synchronized (resourceB){
System.out.println("threadB 获取到 resourceB的锁");

System.out.println("threadB 释放掉 resourceA的锁");
resourceA.wait();
}
}
}catch (Exception ex) {
ex.printStackTrace();
}
});

threadA.start();
threadB.start();

threadA.join();
threadB.join();
}
}

image-20200111215813652

如上代码在main方法里 启动了 A,B两个线程,为了让A先获取到锁,这里让线程B休眠了1s,线程A先后获取到了共享变量resourceA和resourceB上的锁,然后调用了resourceA的wait()方法阻塞挂起自己,阻塞自己后线程A释放掉了获取到的resourceA上的锁。

线程B休眠后结束后会先尝试获取resourceA上的锁,如果当前线程A里边还没有调用resourceA的wait()方法阻塞挂起释放掉该锁,那么线程B就会被阻塞,如果线程A释放了resourceA的锁后,线程B就会获取到resourceA上的锁,然后尝试获取resourceB上的锁。由于线程A中没有释放锁,所以导致线程B尝试获取resourceB上的锁时会被阻塞。

以上就证明了当前线程调用共享变量对象的wait()方法时,当前线程只会释放当前共享对象的锁,当前线程持有其他共享对象的监视器锁并不会被释放。

这里再举个例子说明当一个线程调用共享对象的wait()方法被阻塞挂起后,如果其他线程中断了该线程,则该线程会抛出InterruptedException异常返回。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class WaitNotifyInterrupt {
static Object obj = new Object();

public static void main(String[] args) throws InterruptedException {
Thread testThread = new Thread(() -> {
try {
System.out.println("----begin----");

// 阻塞当前线程
synchronized (obj) {
obj.wait();
}

System.out.println("---end---");
} catch (Exception ex) {
ex.printStackTrace();
}
});

testThread.start();

Thread.sleep(1000);


System.out.println("开始阻断 testThread");
testThread.interrupt();
System.out.println("阻塞 testThread 完毕");
}
}

image-20200112161109221

如上代码,testThread调用了共享变量obj的wait()方法后阻塞挂起了自己,然后主线程休眠1s后中断了testThread线程,中断后testThread再obj.wait()处抛出了java.lang.InterruptedException 异常而返回并终止。

2.wait(long timeout)方法

该方法相比于wait()方法多了一个超时参数,它的不同之处在于,如果一个线程调用共享变量的该方法挂起后,没有再指定的timeout ms时间内被其他线程调用该共享变量的notify()或者notifyAll()方法唤醒,那么该函数还是因为超时而返回。如果将timeoout设置为0那么则和wait()方法效果一样,因为wait()方法内部就是调用了wait(0),需要注意的是,如果在调用该方法时,传递了一个负的timeout则会抛出IllegalArgumentException异常。

3.wait(long timeout, int nanos)方法

在内部调用的是wait(long timeout)函数,如下代码只用nanos>0时才使timeout参数递增1。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public final void wait(long timeout, int nanos) throws InterruptedException {
if (timeout < 0) {
throw new IllegalArgumentException("timeout value is negative");
}

if (nanos < 0 || nanos > 999999) {
throw new IllegalArgumentException(
"nanosecond timeout value out of range");
}

if (nanos > 0) {
timeout++;
}

wait(timeout);
}

4.notify()方法

一个线程调用共享对象的notify方法后,会唤醒一个在该共享变量上调用wait系列方法后被阻塞挂起的线程。一个共享变量上可能会有多个线程在等待,具体唤醒哪个等待的线程是随机的。

此外,被唤醒的线程不能马上从wait方法返回并继续执行,它必须在获取了共享对象的监视器锁后才可以返回,也就是唤醒它的线程释放了共享变量上的监视器锁后,被唤醒的线程也不一定会获取到共享变量的监视器锁,这是因为该线程还需要和其他线程一起竞争该锁,只有该线程竞争到了共享变量的监视器锁后才能继续执行。

类似wait()系列方法,只有当前线程获取到了共享变量的监视器锁后,才可以调用共享变量的notify()方法,否则会抛出 IllegalMonitorStateException异常。

5.notifyAll()方法

不同于在共享变量上调用notify(),会唤醒被阻塞到该共享变量上的一个线程,notifyAll()方法则会唤醒所有在该共享变量由于调用wait()系列方法而被挂起的线程。

下面举个例子来说明notify()和notifyAll()方法具体含义以及一些需要注意的地方。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
public class NotifyTest {

private static volatile Object resourceA = new Object();

public static void main(String[] args) throws InterruptedException {

// 创建线程
Thread threadA = new Thread(() -> {
// 获取resourceA的共享资源锁
synchronized (resourceA) {
System.out.println("threadA 获取到 resourceA 的锁");

try {
System.out.println("threadA 开始调用resourceA的wait()方法进行阻塞挂起");
resourceA.wait();
System.out.println("threadA 结束等待");
} catch (Exception ex) {
ex.printStackTrace();
}
}
});

// 创建线程
Thread threadB = new Thread(() -> {
synchronized (resourceA) {
System.out.println("threadB 获取到 resourceA 的锁");

try {
System.out.println("threadB 开始调用resourceA的wait()方法进行阻塞挂起");
resourceA.wait();
System.out.println("threadB 结束等待");
} catch (Exception ex) {
ex.printStackTrace();
}
}
});

// 创建线程
Thread threadC = new Thread(() -> {
synchronized (resourceA) {
System.out.println("threadC 开始调用 resourceA的notify()方法");
resourceA.notify();
}
});

// 启动线程
threadA.start();
threadB.start();

Thread.sleep(1000);

threadC.start();

// 等待线程执行结束
threadA.join();
threadB.join();
threadC.join();

System.out.println("end---------------------");

}
}

image-20200112170749487

如上代码开启了三个线程,其中A,B线程分别调用了resourceA的wait()方法,线程C在主线程休眠1s后调用了notify()方法。主线程休息1s是为了保证让线程A,B全部执行完wait()方法后再调用线程C的notify()方法。

这个例子试图再线程A和线程B都因调用共享资源resourceA的wait()方法而被阻塞后,让线程C调用resourceA的notify()方法,从而唤醒线程A,B。但是从执行结果来看,只有一个线程A被唤醒,线程B依然在阻塞挂起状态。

从输出结果可知线程调度器这次先调度了线程A占用Cpu来运行,线程A先获取到resourceA的资源所,然后调用wait()方法阻塞挂起,释放锁,而后线程B获取到资源锁,调用resourceA的wait()阻塞挂起。然后线程C调用notify()方法,尝试唤醒线程,这回激活resourceA的阻塞集合里面的一个线程,这里激活了线程A,所以线程A方法执行完毕并返回了。线程B则继续在阻塞等待中。如果把notify()方法换成notifyAll()结果会这样。

image-20200112171809381

换成notifyAll()方法后,可以看到都得到了唤醒。因为上边也说过了notifyAll()方法会唤醒共享变量内所有的等待线程。这里就是唤醒了resourceA的等待集合里所有线程。只是线程B先抢到了resourceA上的锁,然后返回。然后线程A抢到也进行了返回。

尝试把主线程里面的休眠1s去掉,看一下执行结果。

image-20200112172207861

线程B没有正常被唤醒。

这是因为线程C可能比线程B先执行了。如果调用notifyAll()方法后一个线程调用了该共享变量的wait()方法而被放到阻塞集合,则该线程不会被唤醒的,指挥唤醒执行notifyAll()方法前阻塞集合里的所有线程。

对wait(),notify(),notifyAll()的说明结束了

喜欢关注公众号:

qrcode

评论

You forgot to set the shortname for Disqus. Please set it in _config.yml.