devbox
我家自动化
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

02_07_Java语音进阶||day07_等待与唤醒案例、线程池、Lambda表达式_java 语音唤醒

作者：我家自动化 | 2024-02-15 23:43:27

赞

踩

java 语音唤醒

第一章 等待唤醒机制

1.1 线程间通信

  1. 概念：
    • 多个线程在处理同一个资源（包子），但是处理的动作（线程的任务）却不相同。
  2. 比如：
    • 线程A用来生产包子的，线程B用来吃包子的，包子可以理解为同一资源，线程A与线程B处理的动作，一个是生产，一个是消费，那么线程A与线程B之间就存在线程通信问题

1.2 等待唤醒机制

  1. 等待与唤醒机制：线程之间的通信
    • 【重点】：有效的利用资源[包子]（生产一个包子，吃一个包子，再生产一个包子，再吃一个包子）
  2. 通信：对包子的状态进行判断
        * ==没有==包子-->吃货线程唤醒包子铺线程-->吃货线程等待-->包子铺线程做包子-->做好包子-->修改包子的状态==有==
    * ==有==包子-->包子铺线程唤醒吃货线程-->包子铺线程等待-->吃货线程吃包子-->修改包子的状态==没有==
    * ==没有==包子-->吃货线程唤醒包子铺线程-->吃货线程等待-->包子铺线程做包子-->做好包子-->修改包子的状态==有==
    * ...

    • 1
    • 2
    • 3
    • 4
  3. 等待唤醒中的方法
    • void wait()
      • 在其他线程调用此对象的 notify() 方法或 notifyAll() 方法前，导致当前线程等待。
    • void notify()
      • 唤醒在此对象监视器上等待的单个线程。
      • 注：会继续执行wait方法之后的代码
    • void notifyAll()
      • 唤醒在此对象监视器上等待的所有线程。
  4. 注意事项：
    • 哪怕只通知了一个等待的线程，被通知线程也不能立即恢复执行，因为它当初中断的地方是在同步代码块内，而此刻它已经不持有锁，所以它需要再次去获取锁（++很有可能面临其他线程的竞争++），成功后才能在当初调用wait方法之后的地方恢复执行。
  5. 总结：
    • 如果能获取锁，线程就从WAITING状态变成RUNNABLE状态
    • 否则，从wait set出来，又进入entry set，线程又从WAITING状态变成BOLCKED状态
  6. 调用wait和notify方法需要注意的细节
    1. wait和notify必须要由同一个锁对象调用
      • 对应的锁对象可以通过notify唤醒使用同一个锁对象调用的wait方法后的线程
    2. wait与notify是属于Object方法的
      • 锁对象可以是任意对象，而任意对象的所属类都是继承了Object类的
    3. wait和notify必须要在同步代码块或者是同步方法（同步函数）中使用
      • 必须要通过锁对象调用这2个方法

1.3 等待唤醒机制案例分析

  1. 等待唤醒机制其实就是经典的“生产者与消费者”问题
  2. 1.1中包子案例分析：

1.4 等待唤醒机制代码实现

  • 包子铺类的注意事项：
    • 包子铺线程与吃货线程关系–>通信（互斥）
    • 必须使用同步技术两个线程只能有一个在执行
    • 锁对象必须保证唯一，可以使用包子对象作为锁对象
    • 包子铺这个类和吃货这个类把包子对象作为参数传入进来
      1. 需要在成员位置创建一个变量
      2. 使用带参构造方法，为这个包子变量赋值
    //定义一个包子类：BaoZi.java
    /*
    包子类
        属性：
            皮
            馅
            包子的有无状态：true，false
     */
    public class BaoZi {
        //皮
        String pi;
        //馅
        String xian;
        //包子的有无状态：true，false,初始为false
        boolean flag = false;
    
    }
    
    //定义一个包子铺类来继承Thread：BaoZiPu.java
    public class BaoZiPu extends Thread{
        //1. 需要在成员位置创建一个变量
        private BaoZi bz;
    
        //2. 使用带参构造方法，为这个包子变量赋值
        public BaoZiPu(BaoZi bz) {
            this.bz = bz;
        }
    
        //重写run方法：生产包子
        @Override
        public void run() {
            //定义一个变量(用来判断生产那种包子)
            int count = 0;
    
            //while让包子铺一直生产包子
            while (true){
    
                //同步技术，保证两个线程只有一个在执行
                synchronized(bz){ //同步代码块的锁对象就用包子对象
                    //对包子状态进行判断
                    if(bz.flag == true){
                        //调用wait方法进入等待状态
                        try {
                            bz.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
    
                    //被唤醒之后执行，包子铺生产包子
                    //交替生产两种包子
                    if(count % 2 == 0){
                        //生产 薄皮 三鲜馅包子
                        bz.pi = "薄皮";
                        bz.xian = "三鲜馅";
                    }else {
                        //生产 冰皮 牛肉大葱馅包子
                        bz.pi = "冰皮";
                        bz.xian = "牛肉大葱馅";
                    }
                    count++;
                    System.out.println("包子铺正在生产" + bz.pi + bz.xian + "的包子");
    
                    //生产包子需要3秒钟
                    try {
                        Thread.sleep(3000);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                    //包子铺生产好包子后，将包子状态修改为有
                    bz.flag = true;
                    //唤醒吃货线程，让吃货线程吃包子
                    bz.notify();
                    System.out.println("包子铺已经生产好了：" + bz.pi + bz.xian + "的包子,吃货可以开始吃了");
                }
            }
        }
    }
    
    //定义一个吃货类来继承Thread：ChiHuo.java
    public class ChiHuo extends Thread{
        //1. 需要在成员位置创建一个变量
        private BaoZi bz;
    
        //2. 使用带参构造方法，为这个包子变量赋值
        public ChiHuo(BaoZi bz) {
            this.bz = bz;
        }
    
        //重写线程任务run：吃包子
        @Override
        public void run() {
    
            //while让吃货一直吃包子
            while (true){
    
                //同步技术，保证两个线程只有一个在执行
                synchronized(bz) { //同步代码块的锁对象就用包子对象
                    //对包子的状态进行判断
                    if(bz.flag == false){
                        //吃货调用wait方法进入等待状态
                        try {
                            bz.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
    
                    //被唤醒之后执行的代码，吃包子
                    System.out.println("吃货正在吃" + bz.pi + bz.xian + "的包子");
                    //吃货吃完包子后，将包子状态修改为无
                    bz.flag = false;
                    //唤醒包子铺线程，让包子铺生产包子
                    bz.notify();
                    System.out.println("吃货已经把：" + bz.pi + bz.xian + "的包子吃完了，包子铺开始生产包子");
                    System.out.println("=======================");
                }
            }
        }
    }
    
    //主方法（测试类）：Demo.java
    public static void main(String[] args) {
        //创建包子对象
        BaoZi bz = new BaoZi();
        //创建包子铺线程，开启，生产包子
        new BaoZiPu(bz).start();
        //创建吃货线程，开启，吃包子
        new ChiHuo(bz).start();
    }
    
    //结果：
    包子铺正在生产薄皮三鲜馅的包子
    包子铺已经生产好了：薄皮三鲜馅的包子,吃货可以开始吃了
    吃货正在吃薄皮三鲜馅的包子
    吃货已经把：薄皮三鲜馅的包子吃完了，包子铺开始生产包子
    =======================
    包子铺正在生产冰皮牛肉大葱馅的包子
    包子铺已经生产好了：冰皮牛肉大葱馅的包子,吃货可以开始吃了
    吃货正在吃冰皮牛肉大葱馅的包子
    吃货已经把：冰皮牛肉大葱馅的包子吃完了，包子铺开始生产包子
    =======================
    包子铺正在生产薄皮三鲜馅的包子
    ...

  • 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
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134
  • 135
  • 136
  • 137
  • 138
  • 139
  • 140
  • 141
  • 142
  • 143
  • 144

第二章 线程池

2.1 线程池的概念和原理

  1. 线程池的思想概念

2.2 线程池的概念和原理

  1. 概念：
    • 线程池：其实就是一个容纳多个线程的容器【!】，其中的线程可以反复使用，省去了频繁创建线程对象的操作，无需反复创建线程而消耗过多的资源。
  2. 线程池的底层原理：
    • 当程序第一次启动的时候，创建多个线程，保存到一个集合中
    • 当我们想要使用线程的时候，就可以从集合中取出来线程使用
      • Thread t = list.remove(0); //返回的是被移除的元素，（线程只能被一个任务使用）
      • Thread t = linked.removeFirst(0);
    • 当我们使用完线程，需要把线程归还给线程池
      • list.add(t);
      • linked.addLast(t);
    • 常用LinkedList集合
    • 注：JDK1.5之后，内置了线程池，可以直接使用，无需自己写2.3会讲【重点】
  3. 线程池工作原理：
    • 注：如果有5个任务，3个线程，如果线程池中无空闲线程时
      • 任务等待执行
      • 等待其他某个任务执行完毕后，归还线程到线程池
      • 再从线程池中获取线程，执行任务
  4. 线程池的优点：
    1. 降低资源消耗
    2. 提高响应速度
    3. 提高线程的可管理性

2.3 线程池的使用

  1. 线程池:JDK1.5之后提供的
  2. java.util.concurrent.Executors:线程池的工厂类,用来生成线程池
  3. Executors类中的静态方法
    声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家自动化/article/detail/88354
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。