JUC并发编程学习笔记（三）生产者和消费者问题

生产者和消费者问题

synchronized版-> wait/notify
juc版->Lock
面试：单例模式、排序算法、生产者和消费者、死锁

生产者和消费者问题 Synchronized版

1. package org.example.pc;
3. public class A {
4.     public static void main(String[] args) {
5.         Date date = new Date();
6.         new Thread(()->{
7.             for (int i = 0; i < 20; i++) {
8.                 date.increment();
9.             }
10.         },"A").start();
11.         new Thread(()->{
12.             for (int i = 0; i < 20; i++) {
13.                 date.decrement();
14.             }
15.         },"B").start();
16.     }
17. }
18. //判断等待、业务、通知
19. class Date{
20.     private int number = 0;
22.     public synchronized void increment(){
23.         if (number!=0){
24.             try {
25.                 //不等于0就让该线程等待
26.                 this.wait();
27.             } catch (InterruptedException e) {
28.                 throw new RuntimeException(e);
29.             }
30.         }
32.         number++;
33. //        打印加完后的值
34.         System.out.println(Thread.currentThread().getName()+"=>"+number);
35. //        通知其他线程，我完成了
36.         this.notify();
37.     }
38.     public synchronized void decrement(){
39.         if (number!=1){
40.             try {
41.                 this.wait();
42.             } catch (InterruptedException e) {
43.                 throw new RuntimeException(e);
44.             }
45.         }
46.         number--;
47.         System.out.println(Thread.currentThread().getName()+"=>"+number);
48.         this.notify();
49.     }
51. }

复制代码

存在的问题:A、B、C、D四个线程

在线程中判断业务完成唤醒等待应该使用while循环判断，而非if判断，因为if判断值判断一次，在线程中存在一种状态叫虚假唤醒。

JUC版生产者和消费者问题

代码实现

1. package org.example.pc;
3. import java.util.concurrent.locks.Condition;
4. import java.util.concurrent.locks.Lock;
5. import java.util.concurrent.locks.ReentrantLock;
7. //判断等待、业务、通知
8. public class Date {
9.     private int number = 0;
10.     private Lock lock = new ReentrantLock();
11.     private Condition inCondition = lock.newCondition();
13.     public void increment() {
15.         try {
16.             lock.lock();
17.             while (number != 0) {
18.                 inCondition.await();
19.             }
20.             number++;
21. //        打印加完后的值
22.             System.out.println(Thread.currentThread().getName() + "=>" + number);
23. //        通知其他线程，我完成了
25.             inCondition.signalAll();
26.         } catch (Exception e) {
27.             e.printStackTrace();
28.         } finally {
29.             lock.unlock();
30.         }
34.     }
36.     public void decrement() {
38.         try {
39.             lock.lock();
40.             while (number != 1) {
41.                 inCondition.await();
42.             }
43.             number--;
44.             System.out.println(Thread.currentThread().getName() + "=>" + number);
45.             inCondition.signalAll();
46.         } catch (Exception e) {
47.             e.printStackTrace();
48.         } finally {
49.             lock.unlock();
50.         }
53.     }
55. }

复制代码

Condition 精准的通知唤醒线程

在传统并发编程中，通过notifily唤醒线程后所有线程都是随机获取到资源的，JUC中可以通过Condition来精准的控制要唤醒哪一个线程资源。任何一个新技术的出现都不会只是为了实现之前已有的效果
代码实现

1. package org.example.pc;
3. import java.util.concurrent.locks.Condition;
4. import java.util.concurrent.locks.Lock;
5. import java.util.concurrent.locks.ReentrantLock;
7. public class C {
8.     public static void main(String[] args) {
9.         DateC dateC = new DateC();
10.         new Thread(()->{
11.             for (int i = 0; i < 10; i++) dateC.plantA();
12.         },"A").start();
13.         new Thread(()->{
14.             for (int i = 0; i < 10; i++) dateC.plantB();
15.         },"B").start();
16.         new Thread(()->{
17.             for (int i = 0; i < 10; i++) dateC.plantC();
18.         },"C").start();
19.     }
21. }
23. class DateC {
24.     private int number = 1;
25.     private Lock lock = new ReentrantLock();
26.     private Condition inCondition1 = lock.newCondition();
27.     private Condition inCondition2 = lock.newCondition();
28.     private Condition inCondition3 = lock.newCondition();
30.    public void plantA(){
31.        try {
32.            lock.lock();
33.            while (number!=1){
34.                inCondition1.await();
35.            }
36.            System.out.println(Thread.currentThread().getName());
37.            number=2;
38.            inCondition2.signal();
39.        }catch (Exception e){
40.            e.printStackTrace();
41.        }finally {
42.            lock.unlock();
43.        }
44.    }
45.     public void plantB(){
46.         try {
47.             lock.lock();
48.             while (number!=2){
49.                 inCondition2.await();
50.             }
51.             System.out.println(Thread.currentThread().getName());
52.             number=3;
53.             inCondition3.signal();
54.         }catch (Exception e){
55.             e.printStackTrace();
56.         }finally {
57.             lock.unlock();
58.         }
59.     }
60.     public void plantC(){
61.         try {
62.             lock.lock();
63.             while (number!=3){
64.                 inCondition3.await();
65.             }
66.             System.out.println(Thread.currentThread().getName());
67.             number=1;
68.             inCondition1.signal();
69.         }catch (Exception e){
70.             e.printStackTrace();
71.         }finally {
72.             lock.unlock();
73.         }
74.     }
75. }

复制代码

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！