抱歉,您的浏览器无法访问本站
本页面需要浏览器支持(启用)JavaScript
了解详情 >

线程间的协作

多线程的协作

​ 线程开始运行,拥有自己的栈空间,就如同一个脚本一样,按照既定的代码一步一步地执行,直到终止。但是,每个运行中的线程,如果仅仅是孤立地运行,那么没有一点儿价值,或者说价值很少,如果多个线程能够相互配合完成工作,包括数据之间的共享,协同处理事情。这将会带来巨大的价值。

​ 线程之间相互配合,完成某项工作,比如:一个线程修改了一个对象的值,而另一个线程感知到了变化,然后进行相应的操作,整个过程开始于一个线程,而最终执行又是另一个线程。前者是生产者,后者就是消费者,这种模式隔离了“做什么”(what)和“怎么做”(How),简单的办法是让消费者线程不断地循环检查变量是否符合预期在while循环中设置不满足的条件,如果条件满足则退出while循环,从而完成消费者的工作

多线程的协作就像人之间的协作一样,配合完成某样事情,但是线程间协作一下几个难点

  1. 难以确保及时性
  2. 难以降低开销

如果降低睡眠的时间,比如休眠1毫秒,这样消费者能更加迅速地发现条件变化,但是却可能消耗更多的处理器资源,造成了无端的浪费。

等待/通知机制

​ 是指一个线程A调用了对象O的wait()方法进入等待状态,而另一个线程B调用了对象O的notify()或者notifyAll()方法,线程A收到通知后从对象O的wait()方法返回,进而执行后续操作。上述两个线程通过对象O来完成交互,而对象上的wait()和notify/notifyAll()的关系就如同开关信号一样,用来完成等待方和通知方之间的交互工作。

​ 假如有两个线程 一个是为生产者,一个是消费者,生产者生产电池一次一个,消费者使用电池,一次5个,那么这就是两个线程的协作,如果生产多了浪费,生产少了就供应不了消费者了,这个时候可以使用生产者消费者模式,使用一个队列存储生产的电池,生产够了就通知消费者消费,生产者暂停,等消费完了,就通知生产者生产,消费者暂停。

生产者

就是生产电池的线程

消费者

就是使用电池的线程

缓冲区

就是暂时存放电池的地方

等待方法

​ 等待线程忙等待运行时不能有效地利用计算机的CPU,除非平均等待时间非常短。否则,如果等待的线程能以某种方式睡眠或变为非活动状态,直到它收到它正在等待的信号,那将更加智能。

​ Java有一个内置的等待机制,可以让线程在等待信号时变为非活动状态。java.lang.Object类定义了三个方法,wait()notify()notifyAll(),以方便这一点。

wait方法

​ wait()方法是使当前执行代码的线程进行等待,wait()方法是Object类的方法,该方法用来将当前线程置入“欲执行队列”中,并且在wait()所在的代码处停止执行,直到接到通知或被中断为止。在调用wait()方法之前,线程必须获得该对象的对象级别锁,即只能在同步方法或者同步块中调用wait()方法。
在执行wait()方法后,当前线程释放锁。

notify 方法
  方法notify()也要在同步方法或同步块中调用,即在调用前,线程也必须获得该对象的对象级别锁。
notifyAll方法

notify 方法和notifyAll方法类似,notify 方法只是唤醒等待的一个线程notifyAll是唤醒等待的所有线程

notify和notifyAll应该用谁

​ 尽可能用notifyall(),谨慎使用notify(),因为notify()只会唤醒一个线程,我们无法确保被唤醒的这个线程一定就是我们需要唤醒的线程

等待和通知的标准范式

等待方遵循如下原则

1)获取对象的锁。

2)如果条件不满足,那么调用对象的wait()方法,被通知后仍要检查条件。

3)条件满足则执行对应的逻辑

1
2
3
4
5
6
synchronized (对象){
while(条件不满足){
对象.wait();
}
对应的处理逻辑
}
通知方遵循如下原则

1)获得对象的锁。

2)改变条件。

3)通知所有等待在对象上的线程

1
2
3
4
synchronized (对象){
改变条件
对象.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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
package chapter01.demo;

import util.ThreadUtils;

import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.TimeUnit;

public class Battery {
//电池数量
private static int BATTERY_NUM = 0;
//锁对象
private Object less = new Object();

private Object full = new Object();


public static void main(String[] args) {
Battery battery = new Battery();
ExecutorService executorService = Executors.newFixedThreadPool(3);
executorService.execute(() -> {
while (true) {
battery.producer();
}
});
executorService.execute(() -> {
while (true) {
battery.consumer();
}
});

}

/**
* 生产者
*/
public void producer() {
if (BATTERY_NUM >= 5) {
synchronized (full) {
full.notifyAll();
}
}
//持有锁
synchronized (less) {
//数量大于5 需要进行wait等待
while (BATTERY_NUM >= 5) {
try {
System.out.println("生产者阻塞");
less.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//小于5 需要对

ThreadUtils.sleep(1, TimeUnit.SECONDS);
System.out.println("生产一个电池");
BATTERY_NUM++;
}
}

/**
* 消费者
*/
public void consumer() {
if (BATTERY_NUM < 5) {
synchronized (less) {
less.notifyAll();
}
}
//加锁
synchronized (full) {
//数量小于5 需要进行wait等待
while (BATTERY_NUM < 5) {
try {
System.out.println("消费者阻塞");
full.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
//条件满足需要对加锁的方法唤醒
ThreadUtils.sleep(1, TimeUnit.SECONDS);
System.out.println("消费一个电池");
BATTERY_NUM = BATTERY_NUM - 5;
}
}
}

在调用wait()、notify()系列方法之前,线程必须要获得该对象的对象级别锁,即只能在同步方法或同步块中调用wait()方法、notify()系列方法,进入wait()方法后,当前线程释放锁,在从wait()返回前,线程与其他线程竞争重新获得锁, 执行notify()系列方法的线程退出调用了notifyAll的synchronized代码块的时候后,他们就会去竞争。如果其中一个线程获得了该对象锁,它就会继续往下执行,在它退出synchronized代码块,释放锁后,其他的已经被唤醒的线程将会继续竞争获取该锁,一直进行下去,直到所有被唤醒的线程都执行完毕。

评论