多线程详解

最新推荐文章于 2024-11-04 20:33:37 发布

夕山sunset

最新推荐文章于 2024-11-04 20:33:37 发布

阅读量40

点赞数

分类专栏： Java基础知识文章标签： java 开发语言

本文链接：https://blog.csdn.net/m0_59781804/article/details/131366905

版权

Java基础知识专栏收录该内容

1 篇文章 0 订阅

订阅专栏

多线程

1. 概述

1.1 什么是线程

线程(Thread)是一个程序内部的一条执行流程。
程序中如果只有一条执行流程，那这个程序就是单线程的程序。

1.2 多线程是什么

多线程是指从软硬件上实现的多条执行流程的技术（多条线程由CPU负责调度执行）

1.3 多线程用在哪里，有什么好处

消息通信、淘宝、京东系统都离不开多线程技术。

1.4 如何在程序中创建出多条线程？

Java是通过java.lang.Thread 类的对象来代表线程的。

2. 创建方式

2.1 方式一：继承Thread

步骤
- 定义一个子类MyThread继承线程类java.lang.Thread，重写run()方法
```
public class MyThread extends Thread{
    @Override
    public void run() {
        System.out.println("Hello");
    }
}
```
- 创建MyThread类的对象
- 调用线程对象的start()方法启动线程（启动后还是执行run方法的）
优缺点
- 优点：编码简单
- 缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展。

2.2 方式二：实现Runnable接口

步骤
- 定义一个线程任务类MyRunnable实现Runnable接口，重写run()方法
- 创建MyRunnable任务对象
- 把MyRunnable任务对象交给Thread处理。
  - Thread类提供的构造器 public Thread(Runnable target)
    - 封装Runnable对象成为线程对象
- 调用线程对象的start()方法启动线程
```
public class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("Hello");
    }
}

public static void main(String[] args) {
    MyRunnable mr = new MyRunnable();
    Thread thread = new Thread(mr);
    thread.start();
}
```

匿名内部类写法

可以创建Runnable的匿名内部类对象
再交给Thread线程对象。

再调用线程对象的start()启动线程。

// 匿名内部类用法
Thread thread = new Thread(new Runnable() {
    @Override
    public void run() {
        System.out.println("Hello");
    }
});

优缺点
- 优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。
- 缺点：需要多一个Runnable对象（如果线程有执行结果是不能直接返回的）

2.3 方式三：实现Callable接口

概述：
- 方式一和方式二在线程执行完毕后，不能直接返回结果
- JDK5.0提供了Callable接口和FutureTask类可以返回线程执行完毕后的结果

步骤

创建任务对象
- 定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据。
- 把Callable类型的对象封装成FutureTask（线程任务对象）。
把线程任务对象交给Thread对象。
调用Thread对象的start方法启动线程。

线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果。

public class MyCallable implements Callable<String> {
    @Override
    public String call() throws Exception {
        System.out.println("文件上传");
        return "上传完毕";
    }
}

public static void main(String[] args) throws Exception {
    // 创建Callable对象
    MyCallable mc= new MyCallable();
    // 把Callable对象封装成FutureTask对象
    FutureTask<String> ft = new FutureTask<>(mc);
    
    Thread thread = new Thread(ft);
    thread.start();
    // 获取线程执行call方法返回的结果
    String result = ft.get()
    System.out.println(result); // "上传完毕"
}

FutureTask的API
- 构造器
  - public FutureTask<>(Callable call)
    - 把Callable对象封装成FutureTask对象。
- 方法
  - public V get() throws Exception
    - 获取线程执行call方法返回的结果。
优缺点
- 优点：
  - 线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；
  - 可以在线程执行完毕后去获取线程执行的结果
- 缺点：
  - 编码复杂一点。

3. 常用方法

3.1 常见方法

public void run()
- 线程的任务方法
public void start()
- 启动线程
public String getName()
- 获取当前线程的名称，线程名称默认是Thread-索引
public void setName(String name)
- 为线程设置名称
public static Thread currentThread()
- 获取当前执行的线程对象
public static void sleep(long time)
- 让当前执行的线程休眠多少毫秒后，再继续执行
public final void join()...
- 让调用当前这个方法的线程先执行完

3.2 常见构造器

public Thread(String name)
- 可以为当前线程指定名称
public Thread(Runnable target)
- 封装Runnable对象成为线程对象
public Thread(Runnable target, String name)
- 封装Runnable对象成为线程对象，并指定线程名称

Thread类还提供了诸如：yield、interrupt、守护线程、线程优先级等线程的控制方法，在开发中很少使用

4. 多线程的注意事项

4.1 启动线程必须是调用start方法，不是调用run方法。

直接调用run方法会当成普通方法执行，此时相当于还是单线程执行
只有调用start方法才是启动一个新的线程执行

4.2 不要把主线程任务放在启动子线程之前

这样主线程一直是先跑完的，相当于是一个单线程效果

5. 线程安全

5.1 什么是线程安全问题

多个线程，同时操作同一个共享资源的时候，可能会出现业务安全问题。

5.2 线程安全问题出现的原因

多个线程，同时访问同一个共享资源，且存在修改该资源。

6. 线程同步

6.1 认识线程同步

线程同步
- 解决线程安全问题的方案。
线程同步的思想
- 让多个线程实现先后依次访问共享资源，这样就解决了安全问题。
线程同步的常见方案
- 加锁：每次只允许一个线程加锁，加锁后才能进入访问，访问完毕后自动解锁，然后其他线程才能再加锁进来。

6.2 方式

6.2.1 同步代码块

作用
- 把访问共享资源的核心代码给上锁，以此保证线程安全。
synchronized(同步锁) { 访问共享资源的核心代码 }
原理
- 每次只允许一个线程加锁后进入，执行完毕后自动解锁，其他线程才可以进来执行。
同步锁的注意事项
- 对于当前同时执行的线程来说，同步锁必须是同一把（同一个对象），否则会出bug。
- 锁对象最好不要随便选择一个唯一的对象，因为会影响其他无关线程的执行
- 锁对象使用规范
  - 建议使用共享资源作为锁对象，对于实例方法建议使用this作为锁对象（使用this同样有风险，因为有可能不唯一，需要判断锁对象是不是唯一的）。
  - 对于静态方法建议使用字节码（类名.class）对象作为锁对象。

6.2.2 同步方法

作用
- 把访问共享资源的核心方法给上锁，以此保证线程安全。
修饰符 synchronized 返回值类型方法名称(形参列表) { 操作共享资源的代码 }
原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。
底层原理
- 同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。
- 如果方法是实例方法：同步方法默认用this作为的锁对象。（使用this同样有风险，因为有可能不唯一，需要判断锁对象是不是唯一的）。
- 果方法是静态方法：同步方法默认用类名.class作为的锁对象。

同步代码块和同步方法
- 范围上：同步代码块锁的范围更小，同步方法锁的范围更大。
- 可读性：同步方法更好。
6.2.3 Lock锁
- 概述
  - Lock锁是JDK5开始提供的一个新的锁定操作，通过它可以创建出锁对象进行加锁和解锁，更灵活、更方便、更强大。
  - Lock是接口，不能直接实例化，可以采用它的实现类ReentrantLock来构建Lock锁对象。
- 构造器
  - public ReentrantLock()
    - 获得Lock锁的实现类对象
- 常用方法
  - void lock()
    - 获得锁
  - void unlock()
    - 释放锁

7. 线程通信

7.1 概述

什么是线程通信
- 当多个线程共同操作共享的资源时，线程间通过某种方式互相告知自己的状态，可以相互协调，并避免无效的资源争夺。
线程通信的常见模型（生产者与消费者模型）
- 生产者线程负责生产数据
- 消费者线程负责消费生产者生产的数据
- 注意：生产者生产完数据应该等待自己，通知消费者消费；消费者消费完数据也应该等待自己，再通知生产者生产！
线程通信的前提：
- 线程通信通常是在多个线程操作同一个共享资源的时候需要进行通信，且要保证线程安全。

7.2 Object类的等待和唤醒方法

void wait()
- 让当前线程等待并释放所占锁，直到另一个线程调用notify()方法或 notifyAll()方法
void notify()
- 唤醒正在等待的单个线程
void notifyAll()
- 唤醒正在等待的所有线程
使用当前同步锁对象进行调用

8. 线程池

8.1 概述

什么是线程池
- 线程池就是一个可以复用线程的技术。
不使用线程池的问题
- 用户每发起一个请求，后台就需要创建一个新线程来处理，下次新任务来了肯定又要创建新线程处理的，而创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来，这样会严重影响系统的性能。
  
  创建新线程的开销是很大的，并且请求过多时，肯定会产生大量的线程出来
作用：复用线程，提高系统性能
一直在工作的线程叫工作线程：WorkThread
等待的任务在任务队列（WorkQueue）等待

8.2 创建线程池

JDK 5.0起提供了代表线程池的接口：ExecutorService
获取线程池的方式
- 方式一：使用ExecutorService的实现类ThreadPoolExecutor自创建一个线程池对象。（推荐）
  - ThreadPoolExecutor构造器： public ThreadPoolExecutor( int corePoolSize, int maximumPoolSize, long keepAliveTime, TimeUnit unit, BlockingQueue<Runnable> workQueue, ThreadFactory threadFactory, RejectedExecutionHandler handler)
  - 参数一：corePoolSize : 指定线程池的核心线程的数量
  - 参数二：maximumPoolSize：指定线程池的最大线程数量
  - 参数三：keepAliveTime ：指定临时线程的存活时间
  - 参数四：unit：指定临时线程存活的时间单位(秒、分、时、天）
  - 参数五：workQueue：指定线程池的任务队列
  - 参数六：threadFactory：指定线程池的线程工厂
  - 参数七：handler：指定线程池的任务拒绝策略（线程都在忙，任务队列也满了的时候，新任务来了该怎么处理）
- 方式二：使用Executors（线程池的工具类）调用方法返回不同特点的线程池对象。

8.3 注意事项

1、临时线程什么时候创建？
- 新任务提交时发现核心线程都在忙，任务队列也满了，并且还可以创建临时线程，此时才会创建临时线程。
什么时候会开始拒绝新任务？
- 核心线程和临时线程都在忙，任务队列也满了，新的任务过来的时候才会开始拒绝任务。

8.4 ExecutorService的常用方法

void execute(Runnable command)
- 执行 Runnable 任务
Future<T> submit(Callable<T> task)
- 执行 Callable 任务，返回未来任务对象，用于获取线程返回的结果
void shutdown()
- 等全部任务执行完毕后，再关闭线程池！
List<Runnable> shutdownNow()
- 立刻关闭线程池，停止正在执行的任务，并返回队列中未执行的任务

8.5 新任务拒绝策略

ThreadPoolExecutor.AbortPolicy
- 丢弃任务并抛出RejectedExecutionException异常。是默认的策略
ThreadPoolExecutor.DiscardPolicy
- 丢弃任务，但是不抛出异常这是不推荐的做法
ThreadPoolExecutor.DiscardOldestPolicy
- 抛弃队列中等待最久的任务然后把当前任务加入队列中
ThreadPoolExecutor.CallerRunsPolicy
- 由主线程负责调用任务的run()方法从而绕过线程池直接执行

8.6 线程池处理Runnable任务

使用ExecutorService的方法： void execute(Runnable target)

8.7 线程池处理Callable任务

使用ExecutorService的方法： Future<T> submit(Callable<T> command)
因为Callable任务有返回值，如果调用get方法获取返回值，get()方法在尝试拿到结果，拿不到会阻塞。等着拿到结果，就因为这个阻塞，导致池里前面的线程任务执行完了，有新的线程出来，可以处理新来的任务；只要循环中调用get()方法，因为阻塞的问题，底层会一直等待核心线程执行结束！所以临时线程也不创建！
- for (int i = 1; i <= 11; i++) { Future<String> future = pool.submit(new MyCallable(i)); String result = future.get(); System.out.println("结果：" + result); }

8.8 Executors工具类实现线程池

Executors是一个线程池的工具类，提供了很多静态方法用于返回不同特点的线程池对象。
常用方法
- public static ExecutorService newFixedThreadPool(int nThreads)
  
  创建固定线程数量的线程池，如果某个线程因为执行异常而结束，那么线程池会补充一个新线程替代它。
- public static ExecutorService newSingleThreadExecutor()
  
  创建只有一个线程的线程池对象，如果该线程出现异常而结束，那么线程池会补充一个新线程。
- public static ExecutorService newCachedThreadPool()
  
  线程数量随着任务增加而增加，如果线程任务执行完毕且空闲了60s则会被回收掉。
- public static ScheduledExecutorService newScheduledThreadPool(int corePoolSize)
  
  创建一个线程池，可以实现在给定的延迟后运行任务，或者定期执行任务
这些方法的底层，都是通过线程池的实现类ThreadPoolExecutor创建的线程池对象。
Executors使用可能存在的陷阱
- 大型并发系统环境中使用Executors如果不注意可能会出现系统风险。
- Executors是否适合做大型互联网场景的线程池方案，建议使用ThreadPoolExecutor来指定线程池参数，这样可以明确线程池的运行规则，规避资源耗尽的风险。

9. 线程细节知识

9.1 进程

正在运行的程序（软件）就是一个独立的进程。
线程是属于进程的，一个进程中可以同时运行很多个线程。
进程中的多个线程其实是并发和并行执行的。

9.2 并发，并行

并发的含义
- 进程中的线程是由CPU负责调度执行的，但CPU能同时处理线程的数量有限，为了保证全部线程都能往前执行，CPU会轮询为系统的每个线程服务，由于CPU切换的速度很快，给我们的感觉这些线程在同时执行，这就是并发。
并行的理解
- 在同一个时刻上，同时有多个线程在被CPU调度执行
多线程是并发和并行同时进行的

9.3 线程的生命周期

概述
- 也就是线程从生到死的过程中，经历的各种状态及状态转换。
- 理解线程这些状态有利于提升并发编程的理解能力。
Java线程的状态
- Java总共定义了6种状态
- 6种状态都定义在Thread类的内部枚举类中。
  - public class Thread{ ... public enum State { NEW, RUNNABLE, BLOCKED, WAITING, TIMED_WAITING, TERMINATED; } ... }
状态
- New：新建
  - 线程刚被创建，但是并未启动
- Runnable：可运行
  - 线程已经调用了start()，等待CPU调度
- Blocked：锁阻塞
  - 线程在执行的时候未竞争到锁对象，则该线程进入Blocked状态
- Waiting：无限等待
  - 一个线程进入Waiting状态，另一个线程调用notify或者notifyAll方法才能唤醒
- Timed Waiting：计时等待
  - 同Waiting状态，有几个方法（sleep，wait）有超时参数，调用他们进入Timed Waiting状态
- 因为run方法正常退出而死亡，或者因为没有捕获的异常终止了run方法而死亡