JUC：4_1并发协作模型：生产者消费者模型

线程之间的通信问题&＃xff0c;就是生产者和消费者问题&＃xff0c;也就是如何做到多个线程交替执行。

并发协作模型&＃xff1a;生产者消费者模型 解决方式1.管程法
并发协作模型&＃xff1a;生产者消费者模型 解决方式2.信号灯法

上面两个是基于synchronized、wait、notify来去做的&＃xff0c;现在改为Lock去做。

/*** 并发协作模型"生产者/消费者模式"* 线程之间的通信问题&＃xff0c;就是生产者和消费者问题&＃xff0c;也就是如何做到多个线程交替执行* 比如一个线程&＃43;&＃43;A* 一个线程--A* 需要先放入再执行另一个操作*/
public class TestPC {public static void main(String[] args) {SyncContainer container &＃61; new SyncContainer();//生产者new Thread(() -> {for (int i &＃61; 0; i < 100; i&＃43;&＃43;) {container.push(new Product(i));System.out.println("将产品放入缓冲区&＃xff1a;" &＃43; i);}}).start();//消费者new Thread(() -> {for (int i &＃61; 0; i < 100; i&＃43;&＃43;) {System.out.println("消费产品" &＃43; container.pop().getPid());}}).start();}
}//产品
class Product {private int pid;//产品编号public int getPid() {return pid;}public void setPid(int pid) {this.pid &＃61; pid;}public Product(int pid) {this.pid &＃61; pid;}
}//缓冲区
class SyncContainer {//容器大小&＃xff0c;默认容量指定10private static final int DEFAULT_CAPACITY &＃61; 10;Product[] products &＃61; new Product[DEFAULT_CAPACITY];//容器计数器int count &＃61; 0;//生产者放产品public synchronized void push(Product product) {if (count &＃61;&＃61; products.length) {//容器已满&＃xff0c;需要等待消费//通知消费者消费&＃xff0c;生产者等待try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}//容器不满&＃xff0c;可以放产品products[count] &＃61; product;count&＃43;&＃43;;//通知消费者消费&＃xff0c;这里用notifyAll和notify结果都是一样的&＃xff0c;因为不会同时阻塞this.notifyAll();}//消费者消费产品public synchronized Product pop() {//判断容器有无产品&＃xff0c;无则阻塞if (count &＃61;&＃61; 0) {//等待生产者生产&＃xff0c;消费者等待try {this.wait();} catch (InterruptedException e) {e.printStackTrace();}}//可以消费&＃xff0c;这里主要&＃xff1a;count--必须在前&＃xff0c;因为生产者生产之后count&＃43;&＃43;会&＃43;1count--;Product product &＃61; products[count];//通知生产者生产&＃xff0c;这里用notifyAll和notify结果都是一样的&＃xff0c;因为不会同时阻塞this.notify();return product;}
}


输出&＃xff1a;

将产品放入缓冲区&＃xff1a;0
将产品放入缓冲区&＃xff1a;1
将产品放入缓冲区&＃xff1a;2
将产品放入缓冲区&＃xff1a;3
将产品放入缓冲区&＃xff1a;4
将产品放入缓冲区&＃xff1a;5
将产品放入缓冲区&＃xff1a;6
将产品放入缓冲区&＃xff1a;7
将产品放入缓冲区&＃xff1a;8
将产品放入缓冲区&＃xff1a;9
消费产品9
将产品放入缓冲区&＃xff1a;10
消费产品10
将产品放入缓冲区&＃xff1a;11
将产品放入缓冲区&＃xff1a;12
消费产品11
消费产品12
将产品放入缓冲区&＃xff1a;13
消费产品13
将产品放入缓冲区&＃xff1a;14
消费产品14
将产品放入缓冲区&＃xff1a;15
消费产品15
将产品放入缓冲区&＃xff1a;16
将产品放入缓冲区&＃xff1a;17
消费产品16
消费产品17
将产品放入缓冲区&＃xff1a;18
将产品放入缓冲区&＃xff1a;19
消费产品18
消费产品19
将产品放入缓冲区&＃xff1a;20
将产品放入缓冲区&＃xff1a;21
消费产品20
消费产品21
将产品放入缓冲区&＃xff1a;22
消费产品22
将产品放入缓冲区&＃xff1a;23
消费产品23
消费产品24
将产品放入缓冲区&＃xff1a;24
消费产品8
将产品放入缓冲区&＃xff1a;25
消费产品25
将产品放入缓冲区&＃xff1a;26
消费产品26
将产品放入缓冲区&＃xff1a;27
将产品放入缓冲区&＃xff1a;28
消费产品27
将产品放入缓冲区&＃xff1a;29
消费产品29
将产品放入缓冲区&＃xff1a;30
消费产品30
将产品放入缓冲区&＃xff1a;31
消费产品31
将产品放入缓冲区&＃xff1a;32
消费产品32
将产品放入缓冲区&＃xff1a;33
消费产品33
将产品放入缓冲区&＃xff1a;34
消费产品34
将产品放入缓冲区&＃xff1a;35
消费产品35
将产品放入缓冲区&＃xff1a;36
消费产品36
将产品放入缓冲区&＃xff1a;37
消费产品37
将产品放入缓冲区&＃xff1a;38
消费产品38
将产品放入缓冲区&＃xff1a;39
消费产品39
将产品放入缓冲区&＃xff1a;40
消费产品40
将产品放入缓冲区&＃xff1a;41
消费产品41
将产品放入缓冲区&＃xff1a;42
消费产品42
将产品放入缓冲区&＃xff1a;43
消费产品43
将产品放入缓冲区&＃xff1a;44
消费产品44
将产品放入缓冲区&＃xff1a;45
消费产品45
将产品放入缓冲区&＃xff1a;46
消费产品46
将产品放入缓冲区&＃xff1a;47
消费产品47
将产品放入缓冲区&＃xff1a;48
消费产品48
将产品放入缓冲区&＃xff1a;49
消费产品49
将产品放入缓冲区&＃xff1a;50
消费产品50
将产品放入缓冲区&＃xff1a;51
消费产品51
将产品放入缓冲区&＃xff1a;52
消费产品52
将产品放入缓冲区&＃xff1a;53
消费产品53
将产品放入缓冲区&＃xff1a;54
消费产品54
将产品放入缓冲区&＃xff1a;55
消费产品55
将产品放入缓冲区&＃xff1a;56
消费产品56
将产品放入缓冲区&＃xff1a;57
消费产品57
将产品放入缓冲区&＃xff1a;58
消费产品58
将产品放入缓冲区&＃xff1a;59
消费产品59
将产品放入缓冲区&＃xff1a;60
消费产品60
将产品放入缓冲区&＃xff1a;61
消费产品61
将产品放入缓冲区&＃xff1a;62
消费产品62
将产品放入缓冲区&＃xff1a;63
将产品放入缓冲区&＃xff1a;64
消费产品63
消费产品64
消费产品65
将产品放入缓冲区&＃xff1a;65
消费产品28
将产品放入缓冲区&＃xff1a;66
消费产品66
将产品放入缓冲区&＃xff1a;67
消费产品67
将产品放入缓冲区&＃xff1a;68
消费产品68
将产品放入缓冲区&＃xff1a;69
消费产品69
将产品放入缓冲区&＃xff1a;70
消费产品70
将产品放入缓冲区&＃xff1a;71
消费产品71
将产品放入缓冲区&＃xff1a;72
消费产品72
将产品放入缓冲区&＃xff1a;73
消费产品73
将产品放入缓冲区&＃xff1a;74
消费产品74
将产品放入缓冲区&＃xff1a;75
将产品放入缓冲区&＃xff1a;76
消费产品75
将产品放入缓冲区&＃xff1a;77
消费产品77
将产品放入缓冲区&＃xff1a;78
将产品放入缓冲区&＃xff1a;79
消费产品78
消费产品79
将产品放入缓冲区&＃xff1a;80
将产品放入缓冲区&＃xff1a;81
消费产品80
消费产品81
将产品放入缓冲区&＃xff1a;82
消费产品82
将产品放入缓冲区&＃xff1a;83
消费产品83
将产品放入缓冲区&＃xff1a;84
消费产品84
将产品放入缓冲区&＃xff1a;85
将产品放入缓冲区&＃xff1a;86
消费产品85
消费产品86
将产品放入缓冲区&＃xff1a;87
消费产品87
将产品放入缓冲区&＃xff1a;88
消费产品88
将产品放入缓冲区&＃xff1a;89
消费产品89
消费产品90
将产品放入缓冲区&＃xff1a;90
消费产品76
将产品放入缓冲区&＃xff1a;91
消费产品91
将产品放入缓冲区&＃xff1a;92
消费产品92
将产品放入缓冲区&＃xff1a;93
消费产品93
将产品放入缓冲区&＃xff1a;94
消费产品94
将产品放入缓冲区&＃xff1a;95
消费产品95
将产品放入缓冲区&＃xff1a;96
消费产品96
将产品放入缓冲区&＃xff1a;97
消费产品97
将产品放入缓冲区&＃xff1a;98
消费产品98
将产品放入缓冲区&＃xff1a;99
消费产品99
消费产品7
消费产品6
消费产品5
消费产品4
消费产品3
消费产品2
消费产品1
消费产品0

Lock版本的管程法

import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;/*** 并发协作模型"生产者/消费者模式"* 线程之间的通信问题&＃xff0c;就是生产者和消费者问题&＃xff0c;也就是如何做到多个线程交替执行* 比如一个线程&＃43;&＃43;A* 一个线程--A* 需要先放入再执行另一个操作*/
public class TestPC2 {public static void main(String[] args) {SyncContainer container &＃61; new SyncContainer();//生产者new Thread(() -> {for (int i &＃61; 0; i < 100; i&＃43;&＃43;) {container.push(new Product(i));System.out.println("将产品放入缓冲区&＃xff1a;" &＃43; i);}}).start();//消费者new Thread(() -> {for (int i &＃61; 0; i < 100; i&＃43;&＃43;) {System.out.println("消费产品:" &＃43; container.pop().getPid());}}).start();}
}//产品
class Product2 {private int pid;//产品编号public int getPid() {return pid;}public void setPid(int pid) {this.pid &＃61; pid;}public Product2(int pid) {this.pid &＃61; pid;}
}//缓冲区
class SyncContainer2 {//容器大小&＃xff0c;默认容量指定10private static final int DEFAULT_CAPACITY &＃61; 10;Product2[] products &＃61; new Product2[DEFAULT_CAPACITY];final Lock lock &＃61; new ReentrantLock();//默认非公平锁&＃xff0c;可以添加true类型设置为公平锁final Condition productor &＃61; lock.newCondition();final Condition consumer &＃61; lock.newCondition();//容器计数器int count &＃61; 0;//生产者放产品public void push(Product2 product) {lock.lock();//加锁//lock.tryLock();//尝试获取锁&＃xff0c;这个就是和synchronized区别&＃xff0c;不会傻傻的一直等待try {if (count > products.length) {////容器已满&＃xff0c;需要等待消费//通知消费者消费&＃xff0c;生产者等待try {productor.await();} catch (InterruptedException e) {e.printStackTrace();}}//容器不满&＃xff0c;可以放产品products[count] &＃61; product;count&＃43;&＃43;;//通知消费者消费&＃xff0c;这里与sychonized的唤醒时用的notifyAll和notify不同&＃xff0c;用signalconsumer.signal();} finally {lock.unlock();//解锁}}//消费者消费产品public Product2 pop() {lock.lock();//加锁Product2 product;try {//lock.tryLock();//尝试获取锁&＃xff0c;这个就是和synchronized区别&＃xff0c;不会傻傻的一直等待//判断容器有无产品&＃xff0c;无则阻塞if (count &＃61;&＃61; 0) {//等待生产者生产&＃xff0c;消费者等待try {consumer.wait();} catch (InterruptedException e) {e.printStackTrace();}}//可以消费&＃xff0c;这里主要&＃xff1a;count--必须在前&＃xff0c;因为生产者生产之后count&＃43;&＃43;会&＃43;1count--;product &＃61; products[count];productor.signal();} finally {lock.unlock();}return product;}
}