15.多线程概述（下篇）-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_60437068/article/details/142390170

目录

1.进程与线程

2.实现多线程方式一：继承Thread类【应用】

3.实现多线程方式二：实现Runnable接口【应用】

4.实现多线程方式三：实现Callable接口【应用】

5.三种实现方式的对比与套路

6.设置和获取线程名称/线程对象【应用】

7.线程优先级与线程休眠【应用】

8.守护线程【应用】

9.线程同步

10.生产者消费者

11.阻塞队列基本使用与等待唤醒机制【理解】

12.线程状态（状态被定义在了java.lang.Thread.State枚举类中）

13.线程池

14.juc额外扩展资料
1.进程与线程
- 1.1进程：是正在运行的程序
  - 独立性：进程是一个能独立运行的基本单位，同时也是系统分配资源和调度的独立单位
  - 动态性：进程的实质是程序的一次执行过程，进程是动态产生，动态消亡的
  - 并发性：任何进程都可以同其他进程一起并发执行
- 1.2线程：是进程中的单个顺序控制流，是一条执行路径
  - 单线程：一个进程如果只有一条执行路径，则称为单线程程序
  - 多线程：一个进程如果有多条执行路径，则称为多线程程序（会在main线程前运行）
2.实现多线程方式一：继承Thread类【应用】
- 2.1方法介绍
  - void run()
    在线程开启后，此方法将被调用执行
  - void start()
    使此线程开始执行，Java虚拟机会调用run方法()
- 2.2实现步骤
  - 定义一个类MyThread继承Thread类
  - 在MyThread类中重写run()方法
  - 创建MyThread类的对象
  - 启动线程
- 2.3细节
  - 重写run()方法作用：用来封装被线程执行的代码
  - run()方法与start()方法的区别：
    - run()：封装线程执行的代码，直接调用，相当于普通方法的调用（并非调用线程）
    - start()：启动线程；然后由JVM调用此线程的run()方法
3.实现多线程方式二：实现Runnable接口【应用】
- 3.1Thread构造方法
  - Thread(Runnable target)
    分配一个新的Thread对象
  - Thread(Runnable target, String name)
    分配一个新的Thread对象并为其命名
- 3.2实现步骤
  - 定义一个类MyRunnable实现Runnable接口
  - 在MyRunnable类中重写run()方法
  - 创建MyRunnable类的对象
  - 创建Thread类的对象，把MyRunnable对象作为构造方法的参数
  - 启动线程
4.实现多线程方式三：实现Callable接口【应用】
- 4.1方法介绍
  - V call()
    计算结果，如果无法计算结果，则抛出一个异常
  - FutureTask(Callable<V> callable)
    创建一个 FutureTask，一旦运行就执行给定的 Callable
  - V get()
    如有必要，等待计算完成，然后获取其结果
- 4.2实现步骤
  - 定义一个类MyCallable实现Callable接口
  - 在MyCallable类中重写call()方法
  - 创建MyCallable类的对象
  - 创建Future的实现类FutureTask对象，把MyCallable对象作为构造方法的参数
  - 创建Thread类的对象，把FutureTask对象作为构造方法的参数
  - 启动线程
  - 再调用get方法，就可以获取线程结束之后的结果。
- 4.3细节
  - 此方式可以获取多线程运行的结果：也就是return
5.三种实现方式的对比与套路
- 5.1实现Runnable、Callable接口
  - 好处: 扩展性强，实现该接口的同时还可以继承其他的类
  - 缺点: 编程相对复杂，不能直接使用Thread类中的方法
- 5.2继承Thread类
  - 好处: 编程比较简单，可以直接使用Thread类中的方法
  - 缺点: 可以扩展性较差，不能再继承其他的类
- 5.3书写套路
  - 1. while(true)死循环
  - 2. synchronized 锁，锁对象要唯一
  - 3. 判断，共享数据是否结束。结束
  - 4. 判断，共享数据是否结束。没有结束（执行核心逻辑）
6.设置和获取线程名称/线程对象【应用】
- 6.1方法介绍：
  - void setName(String name)
    将此线程的名称更改为等于参数name
  - String getName()
    返回此线程的名称
  - static Thread currentThread()
    返回对当前正在执行的线程对象的引用
    System.out.println(Thread.currentThread().getName());
- 6.2细节：
  - setName细节：如果没有给线程设置名字，默认为格式：Thread-X（X为序号，从0开始）
  - currentThread细节：JVM虚拟机启动之后，会自动的启动多条线程，其中有一条线程就叫做main线程，他的作用就是调用main方法，并执行里面的代码，所有的代码其实都是运行在main线程中
7.线程优先级与线程休眠【应用】
- 7.1线程调度
  - 分时调度模型：所有线程轮流使用 CPU 的使用权，平均分配每个线程占用 CPU 的时间片
  - 抢占式调度模型（Java中使用）：优先让优先级高的线程使用 CPU，如果线程的优先级相同，那么会随机选择一个，优先级高的线程获取的 CPU 时间片相对多一些
  - 注意：优先级不是绝对的，它是一个概率
- 7.2优先级相关方法
  - final int getPriority()
    返回此线程的优先级
  - final void setPriority(int newPriority)
    更改此线程的优先级线程默认优先级是5；线程优先级的范围是：1-10
- 7.3线程休眠方法
  - static void sleep(long millis)
    使当前正在执行的线程停留（暂停执行）指定的毫秒数
    Thread.sleep(100);
8.守护线程【应用】
- 8.1相关方法
  - void setDaemon(boolean on)
    将此线程标记为守护线程，当运行的线程都是守护线程时，Java虚拟机将退出(非守护线程结束，守护线程会陆续结束：一般不会完成)
  - void setDaemon(boolean on)
    出让一次线程/礼让一次线程
  - public static void join()
    插入一次线程/插队一次线程（插入的是当前线程）
- 8.2应用场景
  - QQ聊天的过程中传输文件，其中传输文件就是守护线程，聊天线程关闭后，文件不必再传输
9.线程同步
- 9.1同步代码数据安全问题
  - 安全问题出现的条件
    - 是多线程环境
    - 有共享数据
    - 有多条语句操作共享数据
  - 如何解决多线程安全问题呢?
    - 基本思想：让程序没有安全问题的环境
  - 怎么实现呢?
    - 把多条语句操作共享数据的代码给锁起来，让任意时刻只能有一个线程执行即可
    - Java提供了同步代码块的方式来解决
- 9.2同步代码块
  - 格式：synchronized(任意对象) { 多条语句操作共享数据的代码 }
  - 注意：任意对象可以是任意的但是要保证是唯一
    方式一：static Object obj = new Object()
    方式二：类名.class（表示当前类的字节码文件对象）
    若不是唯一的则锁不住代码，没有意义（例如：this：调用者的本身）
    synchronized(任意对象)：就相当于给代码加锁了，任意对象就可以看成是一把锁
  - 同步的好处与弊端
    - 好处：解决了多线程的数据安全问题
    - 弊端：当线程很多时，因为每个线程都会去判断同步上的锁，这是很耗费资源的，无形中会降低程序的运行效率
- 9.3同步方法块
  - 同步方法块：
    - 格式：修饰符 synchronized 返回值类型方法名(方法参数) { 方法体; }
    - 同步方法锁的对象：this
  - 静态同步方法：
    - 同步静态方法：就是把synchronized关键字加到静态方法上
    - 同步静态方法的锁对象：类名.class
  - 特点：同步方法是锁住方法里面所有的代码
- 9.4Lock锁
  - 我们并没有直接看到在哪里加上了锁，在哪里释放了锁，为了更清晰的表达如何加锁和释放锁，JDK5以后提供了一个新的锁对象Lock
  - ReentrantLock构造方法：ReentrantLock()
    Lock是接口不能直接实例化，这里采用它的实现类ReentrantLock来实例化
    创建一个ReentrantLock的实例
  - 加锁方法：void lock()
    获得锁
  - 解锁方法：void unlock()
    释放锁
  - 注意：unlock()一定要执行，一般放在finally代码块中
- 9.5死锁
  - 概述：线程死锁是指由于两个或者多个线程互相持有对方所需要的资源，导致这些线程处于等待状态，无法前往执行
  - 产生死锁的情况：1.资源有限 2.同步嵌套
10.生产者消费者
- 10.1生产者消费者的俩类线程：
  - 一类是生产者线程用于生产数据
  - 一类是消费者线程用于消费数据
- 10.2生产者与消费者的关系
  - 为了解耦生产者和消费者的关系，通常会采用共享的数据区域，就像是一个仓库
  - 生产者生产数据之后直接放置在共享数据区中，并不需要关心消费者的行为
  - 消费者只需要从共享数据区中去获取数据，并不需要关心生产者的行为
- 10.3Object类的等待与唤醒方法
  - void wait()
    当线程调用对象的wait()方法时，它会释放该对象的监视器锁。这允许其他线程能够进入同步代码块或方法，并获得锁以执行其操作。（与此相反sleep方法不会释放监视器锁）
  - void notify()
    唤醒正在等待对象监视器的单个线程
  - void notifyAll()
    唤醒正在等待对象监视器的所有线程
- 10.4生产者与消费者案例优化【应用】
11.阻塞队列基本使用与等待唤醒机制【理解】
12.线程状态（状态被定义在了java.lang.Thread.State枚举类中）
- 12.1线程状态图【java中无运行状态】
- 12.2java中线程的状态
13.线程池
- 13.1基本原理
  - 系统创建一个线程的成本是比较高的，因为它涉及到与操作系统交互，当程序中需要创建大量生存期很短暂的线程时，频繁的创建和销毁线程对系统的资源消耗有可能大于业务处理是对系统资源的消耗，这样就有点"舍本逐末"了。针对这一种情况，为了提高性能，我们就可以采用线程池。
  - 线程池在启动的时，会创建大量空闲线程，当我们向线程池提交任务的时，线程池就会启动一个线程来执行该任务。
  - 等待任务执行完毕以后，线程并不会死亡，而是再次返回到线程池中称为空闲状态。等待下一次任务的执行。
- 13.2设计思路
  - 1.准备一个任务容器
  - 2.一次性启动多个(2个)消费者线程
  - 3.刚开始任务容器是空的，所以线程都在wait
  - 4.直到一个外部线程向这个任务容器中扔了一个"任务"，就会有一个消费者线程被唤醒
  - 5.这个消费者线程取出"任务"，并且执行这个任务，执行完毕后，继续等待下一次任务的到来
- 13.3线程池-Executors默认线程池
  - 1.静态方法创建线程池
    - static ExecutorService newCachedThreadPool()
      创建一个默认（int最大类型）的线程池
      ExecutorService executorService = Executors.newCachedThreadPool();
    - static newFixedThreadPool(int nThreads)
      创建一个指定最多线程数量的线程池
      ExecutorService executorService = Executors.newFixedThreadPool(10);
    - 其余方法
  - 2.线程池主要核心原理
- 13.4线程池-ThreadPoolExecutor
  - 1.创建线程池对象：
    - ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(核心线程数量,最大线程数量,空闲线程最大存活时间,时间单位,任务队列,创建线程工厂,任务的拒绝策略);
  - 2.线程池参数
    - 参数详解
    - 参数-非默认任务拒绝策略
  - 3.自定义线程池小结
- 13.5线程池的大小
  - 1.向Java虚拟机返回可用处理器的数目
    - int count = Runtime.getRuntime().availableProcessors();
  - 2.线程池取值的大小
14.juc额外扩展资料