学习多线程（三）

线程协作（生产者消费者模式）

应用场景∶生产者和消费者问题

• 假设仓库中只能存放一件产品,生产者将生产出来的产品放入仓库,消费者将仓库中产品取走消费.

• 如果仓库中没有产品﹐则生产者将产品放入仓库，否则停止生产并等待，直到仓库中的产品被消费者取走为止.

• 如果仓库中放有产品﹐则消费者可以将产品取走消费，否则停止消费并等待，直到仓库中再次放入产品为止。

分析

• 这是一个线程同步问题，生产者和消费者共享同一个资源，并且生产者和消费者之间相互依赖,互为条件．

1. 对于生产者﹐没有生产产品之前，要通知消费者等待﹒而生产了产品之后﹐又需要马上通知消费者消费

2. 对于消费者﹐在消费之后,要通知生产者已经结束消费﹐需要生产新的产品以供消费.

3. 在生产者消费者问题中,仅有synchronized是不够的

• synchronized可阻止并发更新同一个共享资源，实现了同步
• synchronized不能用来实现不同线程之间的消息传递(通信)

Java提供了几个方法解决线程之间的通信问题

解决方法1

并发协作模型“生产者l消费者模式”—->管程法

1. 生产者:负责生产数据的模块(可能是方法﹐对象﹐线程,进程);
2. 消费者:负责处理数据的模块(可能是方法﹐对象﹐线程﹐进程);
3. 缓冲区:消费者不能直接使用生产者的数据﹐他们之间有个“缓冲区”

生产者将生产好的数据放入缓冲区,消费者从缓冲区拿出数据

例子：

1. //测试：生产者消费者模型-->利用缓冲区解决：管程法
2. //生产者，消费者，产品，缓冲区
3. public class TestPC {
4. public static void main(String[] args) {
6. SynContainer container = new SynContainer();
8. new Productor(container).start();
9. new Consumer(container).start();
11. }
12. }
14. //生产者
15. class Productor extends Thread{
17. SynContainer container;
19. public Productor(SynContainer container){
20. this.container = container;
21. }
23. //生产
24. @Override
25. public void run() {
26. for (int i = 0; i < 100; i++) {
27. container.push(new Chicken(i));
28. System.out.println("生产了"+i+"只鸡");
29. }
30. }
31. }
33. //消费者
34. class Consumer extends Thread{
36. SynContainer container;
38. public Consumer(SynContainer container){
39. this.container = container;
40. }
41. //消费
42. @Override
43. public void run() {
44. for (int i = 0; i < 100; i++) {
45. System.out.println("消费了--->"+container.pop().id+"只鸡");
46. }
47. }
48. }
50. //产品
51. class Chicken{
52. int id;// 产品编号
54. public Chicken(int id){
55. this.id = id;
56. }
57. }
59. //缓冲区
60. class SynContainer{
61. //需要一个容器大小
62. Chicken[] chickens = new Chicken[10];
63. //容器计算器
64. int count = 0;
66. //生产者放入产品
67. public synchronized void push(Chicken chicken){
68. //如果容器满了，就需要等待消费产品
69. if(count==chickens.length){
70. //生产者等待
71. try {
72. this.wait();
73. } catch (InterruptedException e) {
74. e.printStackTrace();
75. }
76. }
78. //如果没有满，我们就需要丢入产品
79. chickens[count] = chicken;
80. count++;
82. //可以通知消费者消费了
83. this.notifyAll();
84. }
86. //消费者消费产品
87. public synchronized Chicken pop(){
88. //判断能否消费
89. if (count == 0){
90. //等待生产者生产，消费者等待
91. try {
92. this.wait();
93. } catch (InterruptedException e) {
94. e.printStackTrace();
95. }
96. }
98. //如果可以消费
99. count--;
100. Chicken chicken = chickens[count];
102. //吃完了，通知生产者生产
103. this.notifyAll();
104. return chicken;
105. }
106. }

解决方法2

并发协作模型“生产者/消费者模式”—->信号灯法

1. //测试消费者和生产者问题2：信号灯法
2. public class TestPC2 {
3. public static void main(String[] args) {
4. TV tv = new TV();
6. new Player(tv).start();
7. new Watcher(tv).start();
8. }
9. }
11. //生产者-->演员
12. class Player extends Thread{
13. TV tv;
14. public Player(TV tv){
15. this.tv = tv;
16. }
18. @Override
19. public void run() {
20. for (int i = 0; i < 20; i++) {
21. if (i%2==0){
22. this.tv.play("快乐大本营播放中");
23. }else{
24. this.tv.play("抖音，记录有钱人的美好生活");
25. }
26. }
27. }
28. }
30. //消费者-->观众
31. class Watcher extends Thread{
32. TV tv;
33. public Watcher(TV tv){
34. this.tv = tv;
35. }
37. @Override
38. public void run() {
39. for (int i = 0; i < 20; i++) {
40. tv.watch();
41. }
42. }
43. }
45. //产品-->节目
46. class TV{
47. // 演员表演，观众等待 T
48. // 观众观看，演员等待 F
49. String voice; // 表演的节目
50. boolean flag = true;
52. // 表演
53. public synchronized void play(String voice){
54. if (!flag){
55. try {
56. this.wait();
57. } catch (InterruptedException e) {
58. e.printStackTrace();
59. }
60. }
62. System.out.println("演员表演了："+voice);
63. // 通知观众观看
64. this.notifyAll();// 通知唤醒
65. this.voice = voice;
66. this.flag = !this.flag;//flag如果是真就取假，相同是假就取真
67. }
69. // 观看
70. public synchronized void watch(){
71. if (flag){
72. try {
73. this.wait();
74. } catch (InterruptedException e) {
75. e.printStackTrace();
76. }
77. }
79. System.out.println("观众观看了："+voice);
80. // 通知演员表演
81. this.notifyAll();
82. this.flag = !this.flag;
83. }
84. }

Java解决线程之间通信问题的几个方法

方法名	作用
wait()	表示线程一直等待，直到其他线程通知，与sleep不同，会释放锁
wait(long tiimeout)	指定等待的毫秒数
notify()	唤醒一个处于等待状态的线程
notifyAll()	唤醒同一个对象上所有调用wait()方法的线程，优先级别高的线程优先调度

• 注意：均是Object类的方法，都只能在同步方法或者同步代码块中使用，否则会抛出异常IIIegaIMonitorStateException