JUC的等待唤醒机制(wait/notify await/singal)之生产者和消费者问题

 

生产者消费者问题是线程模型中的经典问题：生产者和消费者在同一时间段内共用同一存储空间，生产者向空间里生产数据，而消费者取走数据。

阻塞队列就相当于一个缓冲区，平衡了生产者和消费者的处理能力。这个阻塞队列就是用来给生产者和消费者解耦的。

 

 

一、生产者消费者实现-Object/wait/notify

精简就是：线程操作资源类

仿照官方jdk的文档写：

?
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
import java.util.ArrayList;
import java.util.List;
 
/**
 * @author zhangzhixi
 * @date 2021-4-23 13:38
 */
public class Demo_06_生产者和消费者_实现1 {
    public static void main(String[] args) {
        List list = new ArrayList();
        Resources1 resources1 = new Resources1(list);
        new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                resources1.increment();
            }
        }, "生产").start();
 
        new Thread(() -> {
            for (int i = 1; i <= 5; i++) {
                resources1.decrease();
            }
        }, "消费").start();
    }
}
 
/**
 * 资源类
 */
class Resources1 {
    /**模拟要进行操作的数据*/
    private List list;
 
    public Resources1() {
    }
 
    public Resources1(List list) {
        this.list = list;
    }
 
    /**
     * 生产者线程
     */
    public void increment() {
        // 1、判断
        synchronized (list) {
            while (list.size() != 0) {
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 2、执行添加数据操作(生产)
            Object obj = new Object();
            list.add(obj);
            System.out.println(Thread.currentThread().getName() + "==>" + obj);
            // 3、通知唤醒，提醒消费者进行消费
            list.notify();
        }
    }
 
    /**
     * 消费者线程
     */
    public void decrease() {
        // 1、判断
        synchronized (list) {
            while (list.size() == 0) {
                try {
                    list.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
            // 2、执行移除数据操作
            Object obj = list.remove(0);
            System.out.println(Thread.currentThread().getName() + "==>" + obj);
            // 3、通知唤醒，提醒生产者进行生产
            list.notify();
        }
    }
}

测试：

二、 生产者消费者实现：Lock/await/signal

?
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
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
/**
 * @author zhangzhixi
 * @date 2021-4-23 14:37
 */
public class Demo_06_生产者和消费者_实现2 {
    public static void main(String[] args) {
        Resources2 resources2 = new Resources2();
        new Thread(()->{
            try {
                for (int i = 0; i < 5; i++) {
                    resources2.increment();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"生产者").start();
 
        new Thread(()->{
            try {
                for (int i = 0; i < 5; i++) {
                    resources2.decrease();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        },"消费者").start();
    }
}
 
class Resources2 {
    int number = 0;
    private Lock lock = new ReentrantLock();
    //返回绑定到此Lock实例的新Condition实例
    Condition condition = lock.newCondition();
 
    public void increment() throws InterruptedException {
        lock.lock();
        try {
            // 1、判断
            while (number != 0) {
                // 使当前线程等待
                condition.await();
            }
            // 2、执行操作
            number++;
            System.out.println(Thread.currentThread().getName() + "==>" + number);
            // 3、唤醒消费线程进行消费
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
    public void decrease() throws InterruptedException {
        lock.lock();
        try {
            // 1、判断
            while (number == 0) {
                // 使当前线程等待
                condition.await();
            }
            // 2、执行操作
            number--;
            System.out.println(Thread.currentThread().getName() + "==>" + number);
            // 3、唤醒生产者进行生产
            condition.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

测试：

 三、面试题：Synchronized跟Lock有什么区别，使用Lock的好处是什么

1.原始构成：

Synchronized是属于JVM层面上面的锁，是java中的一个关键字

reentrantLock是属于API层面上面的锁（java.util.concurrent.locks.lock）　　

2.使用方法

Synchronized不需要程序员手动去释放锁，在线程执行结束后，系统会自动让线程释放对锁的占用

reentrantLock是需要程序员手动添加与释放锁的，如果没有释放锁就会出现死锁的情况

　　通常是需要：wait/notify...try/finally语句块进行使用

3.等待是否可中断

Synchronized：不可中断，除非抛出异常，或者程序正常执行完毕

reentrantLock：可以中断：

　　1.设置超时方法：tryLock(long time,TimeUnit unit)：

 　　2.lockInterruptibly()放入代码块中，调用interrupted解锁

4.加锁是否公平

Synchronized：默认非公平锁

reentrantLock：两者都可以，默认的是非公平锁

5.锁绑定多个条件：condition

Synchronized：没有

reentrantLock：可以精确唤醒

四、绑定多个条件：Condition，精准唤醒

?
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
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
 
/**
 * @author zhangzhixi
 * @date 2021-4-23 22:16
 */
public class Demo_07_绑定多个条件_Condition {
    public static void main(String[] args) {
        // 线程操作资源类
        ResourceClass resourceClass = new ResourceClass();
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                resourceClass.print5();
            }
        }, "A").start();
 
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                resourceClass.print10();
            }
        }, "B").start();
 
        new Thread(() -> {
            for (int i = 1; i <= 10; i++) {
                resourceClass.print15();
            }
        }, "C").start();
    }
}
 
/**
 * 题目:多线程之间按顺序调用，实现A->B->C三 个线程启动，要求如下:
 * AA打印5次，BB打印10次，CC打印15次
 * 紧接着.
 * AA打印5次，BB打印10次, CC打印15次
 * 来10轮
 */
class ResourceClass {
    // 唤醒执行的线程：A:1 B:2 c:3
    private int number = 1;
    Lock lock = new ReentrantLock();
    Condition c1 = lock.newCondition();
    Condition c2 = lock.newCondition();
    Condition c3 = lock.newCondition();
 
    public void print5() {
        lock.lock();
        try {
            // 1、判断
            while (number != 1) {
                c1.await();
            }
            // 2、干活
            for (int i = 1; i <= 5; i++) {
                System.out.println(Thread.currentThread().getName() + "==>" + i);
            }
            // 标志位
            number = 2;
            // 3、通知2号线程
            c2.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
    public void print10() {
        lock.lock();
        try {
            // 1、判断
            while (number != 2) {
                c2.await();
            }
            // 2、干活
            for (int i = 1; i <= 10; i++) {
                System.out.println(Thread.currentThread().getName() + "==>" + i);
            }
            // 标志位
            number = 3;
            // 3、通知3号线程
            c3.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
 
    public void print15() {
        lock.lock();
        try {
            // 1、判断
            while (number != 3) {
                c3.await();
            }
            // 2、干活
            for (int i = 1; i <= 15; i++) {
                System.out.println(Thread.currentThread().getName() + "==>" + i);
            }
            // 标志位
            number = 1;
            // 3、通知1号线程
            c1.signal();
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            lock.unlock();
        }
    }
}

 

 

　　

 

posted @   Java小白的搬砖路  阅读(227)  评论(0)  编辑  收藏  举报
编辑推荐：
· go语言实现终端里的倒计时
· 如何编写易于单元测试的代码
· 10年+ .NET Coder 心语，封装的思维：从隐藏、稳定开始理解其本质意义
· .NET Core 中如何实现缓存的预热？
· 从 HTTP 原因短语缺失研究 HTTP/2 和 HTTP/3 的设计差异
阅读排行：
· 分享一个免费、快速、无限量使用的满血 DeepSeek R1 模型，支持深度思考和联网搜索！
· 基于 Docker 搭建 FRP 内网穿透开源项目（很简单哒）
· ollama系列01：轻松3步本地部署deepseek，普通电脑可用
· 按钮权限的设计及实现
· 25岁的心里话

喜欢请打赏

扫描二维码打赏

支付宝打赏

点击右上角即可分享
微信分享提示
SQL AI 助手
❉
❉
❉
❉