目录
等待唤醒机制即通过wait和notify实现多线程之间的通信,进而实现多线程协同工作。
1.普通生产者与消费者方式
生产者和消费者是一种经典的多线程协同工作模式,以厨师(生产者)和顾客(消费者)为例:
厨师和顾客中间有张桌子,厨师会将做好的饭放到桌子上,顾客需要从桌子上拿到饭并吃掉。初始状态下厨师还没有做饭,桌子上是空的,顾客也还没有开始吃饭。
对于厨师而言,他要做以下五种事情:
- 检查桌子上是否还有饭
- 如果桌子上有饭则等待顾客吃完
- 如果没有,则开始做饭
- 将做好的饭放到桌子上
- 通知顾客来吃
对于顾客而言,他要做以下四种事情:
- 检查桌子上是否有饭
- 如果没有饭则等待厨师做好饭
- 如果有饭则开始吃饭
- 吃完饭后通知厨师继续开始做饭
如果用代码实现上面的通知和等待,则要用到下面三种方法:
其中通知经常是用notifyAll,因为如果线程有很多,使用notify仅能随机唤醒一个线程,那可能要唤醒好多次才能唤醒所需要的线程,而notifyAll能唤醒所有线程,自然也会唤醒所需要的线程,所以一般使用notifyAll用来通知。
用代码实现上面的顾客、厨师以及桌子:
//桌子Table
public class Table {
//桌子上是否有饭的信号,0代表没有饭,1代表有饭
public static int flag=0;
//顾客吃饭的目标
public static int count=3;
//顾客和厨师共享的锁,因为对于共享资源加的锁必须是唯一的
public static Object object=new Object();
}
//顾客Customer
public class Customer extends Thread{
@Override
public void run() {
synchronized (Table.object){
while (true){
//先检查自己是否已经达成了吃饭的目标
//如果已经达到了就break
//如果没有则进行接下来的操作
if(Table.count==0){
System.out.println("顾客达成了目标,结账走人了。");
break;
}else{
//1.先检查桌子上有没有饭
//2.如果有则执行吃饭操作
//3.如果没有则等待厨师做饭
if(Table.flag==1){
System.out.println("顾客正在吃饭中...");
//将饭从桌子上拿走
Table.flag=0;
//吃了这碗饭后离目标又近了一步
Table.count--;
System.out.println("饭吃完了,还剩"+Table.count+"碗饭没吃,正在通知厨师做饭...");
//4.吃完饭后通知厨师继续做饭
Table.object.notifyAll();
}else {
try {
Table.object.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
}
}
}
//厨师Cook
public class Cook extends Thread{
@Override
public void run() {
synchronized (Table.object) {
while (true) {
//先判断是否顾客已经达成吃饭的目标
//如果吃饭的目标达成则退出循环
//如果没有则继续接下来的操作
if(Table.count==0){
System.out.println("厨师了解到顾客达成了目标,结束做饭。");
break;
}else{
//1.先检查桌子上有没有饭
//2.如果没有则开始做饭
//3.如果有则进入等待
if(Table.flag==0){
System.out.println("厨师正在做饭中...");
//4.饭做好了,将饭放到桌子上
Table.flag=1;
//5.通知顾客来吃
//唤醒所有绑定到这个锁的线程
System.out.println("饭做好了,已放到桌子上,正在通知顾客来吃...");
Table.object.notifyAll();
}else{
try {
//绑定加上这个共享锁的线程,并让该线程进入等待状态
Table.object.wait();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
}
}
}
//模拟顾客和厨师的过程
public class Main {
public static void main(String[] args) {
Thread t1=new Customer();
Thread t2=new Cook();
t1.start();
t2.start();
}
}
运行结果:
首先要注意的是顾客和厨师是两个线程类而不是两个普通的类。然后就是Table相当于管理共享的变量,共享的变量要设置为静态的。最后就是在调用wait和notifyAll时要使用共享锁来调用,用共享锁调用wait会将这个锁和添加这个锁的线程进行绑定,在用这个共享锁调用notifyAll时会唤醒绑定这个锁的所有线程,从而在唤醒时不会通知其他无关的线程。
下面使用lambda表达式来实现:
//资源类,饭
public class Food {
//桌子上的食物数量
private int num=0;
//目标一共需要吃十碗饭
private int sumnum=10;
//厨师的做饭方法
public synchronized boolean cook() throws InterruptedException {
//检查是否达到了目标
if(sumnum==0){
return false;
}
//是否需要等待
if(num!=0){
this.wait();
}else{
//做饭的业务代码
num++;
System.out.println(Thread.currentThread().getName()+"做好了一碗饭,当前有"+num+"碗饭");
//饭做好了,通知顾客来吃
this.notifyAll();
}
return true;
}
//顾客的吃饭方法
public synchronized boolean eat() throws InterruptedException {
//检查是否达到了目标
if(sumnum==0){
return false;
}
//是否需要等待
if(num==0){
this.wait();
}else{
//吃饭的业务代码
num--;
sumnum--;
System.out.println(Thread.currentThread().getName()+"吃了一碗饭,当前有"+num+"碗饭");
//饭吃完了,通知厨师继续做
this.notifyAll();
}
return true;
}
}
//实现
public class Main {
public static void main(String[] args) {
//创建资源类Food的对象
Food food=new Food();
//创建厨师线程
Thread c1=new Thread(()->{
while (true){
try {
if(!food.cook())
break;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"做饭线程1");
//创建顾客线程
Thread e1=new Thread(()->{
while (true){
try {
if(!food.eat())
break;
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
},"吃饭线程1");
//启动厨师和顾客的线程
c1.start();
e1.start();
}
}
注意一定要使用if-else语句,将业务代码和通知放在else中:
//正确格式
if(等待条件){
wait;
}else{
业务代码;
notifyAll;
}
//错误格式
if(等待条件){
wait;
}
业务代码;
notifyAll;
如果使用错误格式将业务代码和通知放到外面,那么这个线程在被唤醒后会接着执行业务代码,但是如果这个线程还不满足执行业务代码的条件,由于其他线程调用了notifyAll唤醒了所有的线程,那么这个线程会在不满足条件下开始执行业务代码,这就是虚假唤醒。如果将这些代码放入else中,即使这个线程在不满足条件下被唤醒也不会执行业务代码,而是会进入下一次循环,在进入下一次循环后又会判断是否满足条件。
在使用等待唤醒机制实现线程之间的通信时,可以利用口诀“等待、业务、通知”来编写要执行的方法:
//先判断是否需要等待,如果满足等待条件,执行wait
//业务代码
//使用notifyAll通知其他线程
if(等待条件){
this.wait();
}else{
业务代码
this.notifyAll();
}
2.加入阻塞队列
阻塞队列就相当于替换掉了中间的桌子,顾客吃饭时从阻塞队列中拿,厨师做好饭后将饭放到阻塞队列中;阻塞队列由于是一个队列,会遵循先入先出。桌子只能放一碗饭,而阻塞队列可以放多碗饭;并且阻塞队列的底层已经加锁了,不需要我们手动加锁。
阻塞队列有两种,一种是ArrayBlockingQueue<类型>,底层是基于数组的,所以这种阻塞队列的空间是有限的;另一种是LinkedBlockingQueue<类型>,底层是基于链表的,所以这种阻塞队列的空间理论上是无限的,但实际上它的最大长度不能超过int的范围。
用阻塞队列实现起来很简单,生产者只需要向里面放东西,也就是调用put方法,消费者只需要从里面取东西就行了,也就是调用take方法。下面是put和take的源码:
put:
take:
下面用阻塞队列来实现顾客和厨师:
//厨师
public class Cook extends Thread{
ArrayBlockingQueue<String> queue;
public Cook(ArrayBlockingQueue<String> queue){
this.queue=queue;
}
@Override
public void run() {
while (true){
try {
queue.put("饭");
System.out.println("厨师做好了一碗饭");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
//顾客
public class Customer extends Thread{
ArrayBlockingQueue<String> queue;
public Customer(ArrayBlockingQueue<String> queue){
this.queue=queue;
}
@Override
public void run() {
while (true){
try {
String food=queue.take();
System.out.println("顾客拿走了一碗饭");
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
}
}
//模拟顾客和厨师的过程
public class Main {
public static void main(String[] args) {
//由于阻塞队列只能有一个,所以阻塞队列不能在Cook或Customer中创建,直接从main中创建即可
ArrayBlockingQueue<String> queue=new ArrayBlockingQueue<String>(1);
//将这个阻塞队列分别传递给Cook和Customer,保证两者使用的是同一个阻塞队列
Thread t1=new Cook(queue);
Thread t2=new Customer(queue);
t1.start();
t2.start();
}
}
运行结果:
在上面的代码中, 我们给阻塞队列设置的空间为1,那应该输出的是厨师放一碗饭顾客拿一碗饭才对,而这里却出现了厨师连放多次饭以及顾客连取多次饭的情况,这难道是取和放的时候出现了问题吗?
其实并不是,因为put和take的底层已经进行了加锁和解锁的操作,所以这两个过程是没有问题的,问题出在后面的输出语句。虽然put和take进行了加锁,但是输出的操作并没有加锁,这很可能出现乱输出的情况,毕竟线程的运行完全随机,永远不知道下一秒是哪个线程在占用CPU。不过虽然输出操作会出现问题,但这对实现顾客和厨师的过程并不会产生影响,因为输出操作只是用来给自己看的,实际运行过程不出错即可。