Java 基础进阶篇（十六）：多线程总结

妖狐艹你老母 2023-10-11 22:06 6阅读 0赞

#### 文章目录 ####

*  一、多线程概述
 *  二、多线程的创建
 *   *  1.1 方式一：继承 Thread 类
     *  1.2 方式二：实现 Runnable 接口
     *   *  匿名内部类实现方案
     *  1.3 方式三：JDK 5.0新增: 实现 Callable 接口
     *  1.4 三种方式对比
 *  二、Thread的常用方法
 *  三、线程安全与同步
 *   *  3.1 线程安全
     *  3.2 线程同步
     *   *  3.2.1 方式一：同步代码块
         *  3.2.2 方式二：同步方法
         *  3.2.3 方式三：Lock锁
 *  四、线程通信
 *  五、线程池 ★
 *   *  5.1 线程池概述
     *  5.2 线程池实现的API
     *   *  5.2.1 线程池处理Runnable任务
         *  5.2.2 线程池处理 Callable 任务
         *  5.2.3 面试题
     *  5.3 Executors工具类实现线程池

--------------------

## 一、多线程概述 ##

线程（Thread）是一个程序内部的一条执行路径。我们之前启动程序执行后，main 方法的执行其实就是一条单独的执行路径。程序中如果只有一条执行路径，那么这个程序就是单线程的程序。Java 是通过 java.lang.Thread 类来代表线程的，Thread 类提供了实现多线程的方式 。

--------------------

## 二、多线程的创建 ##

### 1.1 方式一：继承 Thread 类 ###

步骤：

> ① 定义一个子类 MyThread 继承线程类 java.lang.Thread，重写 run() 方法  
> ② 创建 MyThread 类的对象  
> ③ 调用线程对象的 start() 方法启动线程（启动后还是执行 run 方法）

优缺点：

> 优点：编码简单。  
> 缺点：线程类已经继承 Thread，无法继承其他类，不利于扩展。

举例：

// 1、定义一个线程类继承Thread类
    public class MyThread extends Thread{
        
         // 2、重写run方法，里面是定义线程以后要干啥
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println("子线程执行输出：" + i);
            }
        }
    }
    
    public class ThreadDemo1 {
        
        public static void main(String[] args) {
        
            // 3、new一个新线程对象
            Thread t = new MyThread();
            // 4、调用start方法启动线程（执行的还是run方法）
            t.start();
    
            for (int i = 0; i < 5; i++) {
        
                System.out.println("主线程执行输出：" + i);
            }
        }
    }

输出：  
![在这里插入图片描述][9ab67ad4e3bc425aba793f114f37739a.png_pic_left]

注意：

1.  如果直接调用 run 方法会当成普通方法执行，此时相当于还是单线程执行。只有调用 start 方法才是启动一个新的线程执行。
2.  把主线程任务放在子线程之前，这样主线程一直是先跑完的，相当于是一个单线程的效果了。

--------------------

### 1.2 方式二：实现 Runnable 接口 ###

步骤：

> ① 定义一个线程任务类 MyRunnable 实现 Runnable 接口，重写 run() 方法  
> ② 创建 MyRunnable 任务对象  
> ③ 把 MyRunnable 任务对象交给 Thread 处理  
> ④ 调用线程对象的 start() 方法启动线程

构造器：

![在这里插入图片描述][ddafc60ca6ae40fabd6db38561a08186.png_pic_left]  
注：其中第一种方法，是通过子类的有参构造，来调用 Thread 类的有参构造，以此来指定线程名称（举例看Thread常用方法）

public class MyThread extends Thread{
        
        public MyThread(String name) {
        
            // 为当前线程对象设置名称，送给父类的有参数构造器初始化名称
            super(name);
        }
        @Override
        public void run() {
        
            ....
        }
    }

优缺点：

> ① 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强。  
> ② 缺点：编程多一层对象包装，如果线程有执行结果是不可以直接返回的。

举例：

// 1、定义一个线程任务类 实现Runnable接口
    class MyRunnable  implements Runnable {
        
         // 2、重写run方法，定义线程的执行任务的
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println("子线程执行输出：" + i);
            }
        }
    }
    
    public class ThreadDemo2 {
        
        public static void main(String[] args) {
        
            // 3、创建一个任务对象
            Runnable target = new MyRunnable();
            // 4、把任务对象交给Thread处理
            Thread t = new Thread(target);
            // Thread t = new Thread(target, "1号");
            // 5、启动线程
            t.start();
    
            for (int i = 0; i < 5; i++) {
        
                System.out.println("主线程执行输出：" + i);
                // System.out.println(Thread.currentThread().getName()+"主线程执行输出：" + i); // 获取线程的名字
            }
        }
    }

输出：

![在这里插入图片描述][9281c2064da548cdac3e3b583da3df29.png_pic_left]  
注：主线程默认 “main”，子线程默认名字 “Thread-index”，index 从 0 开始。

--------------------

#### 匿名内部类实现方案 ####

步骤：

> ① 创建 Runnable 的匿名内部类对象  
> ② 交给 Thread 处理  
> ③ 调用线程对象的 start() 启动线程

举例：

public class ThreadDemo2Other {
        
        public static void main(String[] args) {
        
            // 创建匿名内部类对象，并交给 Thread 处理
            Runnable target = new Runnable() {
        
                @Override
                public void run() {
        
                    for (int i = 0; i < 10; i++) {
        
                        System.out.println("子线程1执行输出：" + i);
                    }
                }
            };
            Thread t = new Thread(target);
            t.start();
    
            // 化简形式
            new Thread(new Runnable() {
        
                @Override
                public void run() {
        
                    for (int i = 0; i < 10; i++) {
        
                        System.out.println("子线程2执行输出：" + i);
                    }
                }
            }).start();
    
            // Lambda 化简
            new Thread(() -> {
        
                for (int i = 0; i < 10; i++) {
        
                    System.out.println("子线程3执行输出：" + i);
                }
            }).start();
    
            for (int i = 0; i < 10; i++) {
        
                System.out.println("主线程执行输出：" + i);
            }
        }
    }

--------------------

### 1.3 方式三：JDK 5.0新增: 实现 Callable 接口 ###

前两种方式存在的问题：他们重写的 run 方法均不能直接返回结果，不适合需要返回线程执行结果的业务场景。

问题解决：JDK 5.0 提供了 Callable 和 FutureTask 来实现，这种方式的优点是，可以得到线程执行的结果。

步骤：

> ① 得到任务对象：定义类实现 Callable 接口，重写 call 方法，封装要做的事情；用 FutureTask 把 Callable 对象封装成线程任务对象。  
> ② 把线程任务对象交给 Thread 处理。  
> ③ 调用 Thread 的 start 方法启动线程，执行任务  
> ④ 线程执行完毕后，通过 FutureTask 的 get 方法去获取任务执行的结果。

常用API：

![在这里插入图片描述][c3ae3e34495b48e4847193b0315c8e9a.png_pic_left]

优缺点：

> ① 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果。  
> ② 缺点：编码复杂一点。

举例：

// 1、定义一个任务类 实现 Callable 接口  应该申明线程任务执行完毕后的结果的数据类型
    class MyCallable implements Callable<String>{
        
        private int n;
        public MyCallable(int n) {
        
            this.n = n;
        }
    
         // 2、重写call方法（任务方法）
        @Override
        public String call() throws Exception {
        
            int sum = 0;
            for (int i = 1; i <= n ; i++) {
        
                sum += i;
                System.out.println(Thread.currentThread().getName());
            }
            return "子线程执行的结果是：" + sum;
        }
    }

public class ThreadDemo3 {
        
        public static void main(String[] args) {
        
            // 3、创建 Callable 任务对象
            Callable<String> call = new MyCallable(100);
            // 4、把 Callable 任务对象 交给 FutureTask 对象
            // FutureTask 对象的作用 1： 是 Runnable 的对象（实现了 Runnable 接口），可以交给 Thread 了
            // FutureTask 对象的作用 2： 可以在线程执行完毕之后通过调用其 get 方法得到线程执行完成的结果
            FutureTask<String> f1 = new FutureTask<>(call);
            // 5、交给线程处理
            Thread t1 = new Thread(f1);
            // 6、启动线程
            t1.start();
    
            Callable<String> call2 = new MyCallable(200);
            FutureTask<String> f2 = new FutureTask<>(call2);
            Thread t2 = new Thread(f2);
            t2.start();
    
            try {
        
                // 如果 f1 任务没有执行完毕，这里的代码会等待，直到线程1 跑完才提取结果。
                String rs1 = f1.get();
                System.out.println("第一个结果：" + rs1);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
    
            try {
        
                // 如果 f2 任务没有执行完毕，这里的代码会等待，直到线程2 跑完才提取结果。
                String rs2 = f2.get();
                System.out.println("第二个结果：" + rs2);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

输出：

![在这里插入图片描述][91353056126b4eeba699de8c0e699fbb.png_pic_left]

--------------------

### 1.4 三种方式对比 ###

![在这里插入图片描述][913337d09c1847ccbae5be41655e0720.png_pic_left]

--------------------

## 二、Thread的常用方法 ##

![在这里插入图片描述][7089dc30a78247ce99be836e214fc49e.png_pic_left]

举例1：

public class MyThread extends Thread{
        
        public MyThread() {
        
        }
        public MyThread(String name) {
        
            // 为当前线程对象设置名称，送给父类的有参数构造器初始化名称
            super(name);
        }
    
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println(Thread.currentThread().getName() + "输出：" + i);
            }
        }
    }
    
    public class ThreadDemo01 {
        
        public static void main(String[] args) {
        
            Thread t1 = new MyThread("1号"); // 需要重写有参构造方法
            // t1.setName("1号");
            t1.start();
            System.out.println(t1.getName());
    
            Thread t2 = new MyThread("2号");
            // t2.setName("2号");
            t2.start();
            System.out.println(t2.getName());
    
            // 哪个线程执行它，它就得到哪个线程对象（当前线程对象）
            Thread m = Thread.currentThread();
            System.out.println(m.getName()); // main
    
            for (int i = 0; i < 5; i++) {
        
                System.out.println( m.getName() + "输出：" + i);
            }
        }
    }

输出：  
![在这里插入图片描述][705cf32606d84b16901da20751e65b6e.png_pic_left]

注：如果使用 `Thread.currentThread().getName()` 就全部都使用， 否则只是`Thread.currentThread().getName()` 会有线程效果。

--------------------

## 三、线程安全与同步 ##

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

### 3.1 线程安全 ###

线程安全问题模拟案例：

需求：小明和小红是一对夫妻，他们有一个共同的账户，余额是10万元。如果小明和小红同时来取钱，而且2人都要取钱10万元，可能出现什么问题呢？

/**
     * 账户类
     */
    public class Account {
        
        private String cardId;
        private double money; // 账户的余额
        public Account(){
        
        }
        public Account(String cardId, double money) {
        
            this.cardId = cardId;
            this.money = money;
        }
    
        // 小明 小红：取钱
        public void drawMoney(double money) {
        
            // 0、先获取是谁来取钱，线程的名字就是人名
            String name = Thread.currentThread().getName();
            // 1、判断账户是否够钱
            if(this.money >= money){
        
                // 2、取钱
                System.out.println(name + "来取钱成功，吐出：" + money);
                // 3、更新余额
                this.money -= money;
                System.out.println(name + "取钱后剩余：" + this.money);
            }else {
        
                // 4、余额不足
                System.out.println(name +"来取钱，余额不足！");
            }
        }
        ...
    }

/**
     * 取钱的线程类
     */
    public class DrawThread extends Thread {
        
        // 接收处理的账户对象
        private Account acc;
        public DrawThread(Account acc,String name){
        
            super(name);
            this.acc = acc;
        }
        @Override
        public void run() {
        
            // 小明 小红：取钱
            acc.drawMoney(100000);
        }
    }

/**
     * 需求：模拟取钱案例。
     */
    public class ThreadDemo {
        
        public static void main(String[] args) {
        
            // 1、定义线程类，创建一个共享的账户对象
            Account acc = new Account("ICBC-111", 100000);
    
            // 2、创建2个线程对象，代表小明和小红同时进来了。
            new DrawThread(acc, "小明").start();
            new DrawThread(acc, "小红").start();
        }
    }

输出：  
![在这里插入图片描述][e15ff5784cd748c1a4ba2b838f5e653b.png_pic_left_400x]

分析问题：  
取钱案例出现问题的原因？多个线程同时执行，发现账户都是够钱的  
如何才能保证线程安全呢？让多个线程实现先后依次访问共享资源，这样就解决了安全问题

--------------------

### 3.2 线程同步 ###

同步思想概述：加锁，即让多个线程实现先后依次访问共享资源，这样就解决了安全问题。

#### 3.2.1 方式一：同步代码块 ####

作用：把出现线程安全问题的核心代码给上锁。  
原理：每次只能一个线程进入，执行完毕后自动解锁，其他线程才可以进来执行。

![在这里插入图片描述][4bc9edd2095a4197a37435f2f487f493.png_pic_left]  
案例修改：

// 小明 小红：取钱
    public void drawMoney(double money) {
        
    	// 1、拿到是谁来取钱
    	String name = Thread.currentThread().getName();
    	// 同步代码块
    	synchronized (this) {
        
    	    // 2、判断余额是否足够
    	    if(this.money >= money){
        
    	        // 钱够了
    	        System.out.println(name+"来取钱，吐出：" + money);
    	        // 更新余额
    	        this.money -= money;
    	        System.out.println(name+"取钱后，余额剩余：" + this.money);
    	    }else{
        
    	        // 3、余额不足
    	        System.out.println(name+"来取钱，余额不足！");
    	    }
    	}
    }

`synchronized (共享锁对象)` 共享锁对于线程来说是唯一对象即可。

如：`synchronized ("acc")` 对于共享同一个账户的小明小红是同一个对象，但是如果有两个共享账户，那 `"acc"` 这个对象也是对于两个共享账户下的不同线程而言，也是同一个对象。因此 `synchronized ("acc")` 不同共享账户下的线程也会使用同一把锁，即锁住了千家万户。

标准的写法 `synchronized (this)`，这样以来，线程对于同一个共享账户都有一把锁。

锁对象要求：规范上：建议使用共享资源作为锁对象。

> 对于实例方法：建议使用 this 作为锁对象。  
> 对于静态方法：建议使用字节码（类名.class）对象作为锁对象。

举例静态方法：

public static void drawMoney(){
        
    	synchronized (Account.class){
        
    		...
    	}
    }

--------------------

#### 3.2.2 方式二：同步方法 ####

作用：把出现线程安全问题的核心方法给上锁。  
原理：每次只能一个线程进入，执行完毕以后自动解锁，其他线程才可以进来执行。

![在这里插入图片描述][7d74fa08fb664e76abf89c0e05bc62b4.png_pic_left]

底层原理：同步方法其实底层也是有隐式锁对象的，只是锁的范围是整个方法代码。

> 如果方法是实例方法：同步方法默认用 this 作为的锁对象。  
> 如果方法是静态方法：同步方法默认用 类名.class 作为的锁对象。

案例修改：

// 小明 小红：取钱
    public synchronized void drawMoney(double money) {
        
    	// 1、拿到是谁来取钱
    	String name = Thread.currentThread().getName();
    	// 2、判断余额是否足够
    	// 小明  小红
    	if(this.money >= money){
        
    	    // 钱够了
    	    System.out.println(name+"来取钱，吐出：" + money);
    	    // 更新余额
    	    this.money -= money;
    	    System.out.println(name+"取钱后，余额剩余：" + this.money);
    	}else{
        
    	    // 3、余额不足
    	    System.out.println(name+"来取钱，余额不足！");
    	}
    }

输出：  
![在这里插入图片描述][f389b89bc59848daadcc9d1970ea2a13.png]

两种方式对比：同步代码块锁的范围更小，同步方法锁的范围更大。

--------------------

#### 3.2.3 方式三：Lock锁 ####

为了更清晰的表达如何加锁和释放锁，JDK5 以后提供了一个新的锁对象 Lock，更加灵活、方便。  
Lock 实现提供比使用 synchronized 方法和语句可以获得更广泛的锁定操作。  
Lock 是接口不能直接实例化，这里采用它的实现类 ReentrantLock 来构建 Lock 锁对象。

![在这里插入图片描述][1c4374dfede84ff5b65e5bb1c9ff59b9.png_pic_left]  
案例修改：

// 方法里面定义Lock锁的实现类对象的成员变量
    private final Lock lock = new ReentrantLock();
    // 小明 小红：取钱
    public void drawMoney(double money) {
        
    	// 1、拿到是谁来取钱
    	String name = Thread.currentThread().getName();
    	// 2、判断余额是否足够
    	// 小明  小红
    	lock.lock(); // 上锁
    	try {
        
    	    if(this.money >= money){
        
    	        // 钱够了
    	        System.out.println(name+"来取钱，吐出：" + money);
    	        // 更新余额
    	        this.money -= money;
    	        System.out.println(name+"取钱后，余额剩余：" + this.money);
    	    }else{
        
    	        // 3、余额不足
    	        System.out.println(name+"来取钱，余额不足！");
    	    }
    	} finally {
        
    	    lock.unlock(); // 解锁
    	}
    }

--------------------

## 四、线程通信 ##

线程通信就是线程间相互发送数据，线程间共享一个资源即可实现线程通信。

常见形式：通过共享一个数据的方式实现。根据共享数据的情况决定自己该怎么做，以及通知其他线程怎么做。

实际应用场景：生产者与消费者模型，生产者线程负责生产数据，消费者线程负责消费生产者产生的数据。  
要求：生产者线程生产完数据后唤醒消费者，然后等待自己，消费者消费完该数据后唤醒生产者，然后等待自己。

参考：[经典同步问题：https://blog.csdn.net/weixin\_43819566/article/details/128824443][https_blog.csdn.net_weixin_43819566_article_details_128824443]

Object类的等待和唤醒方法：

![在这里插入图片描述][9f21207574f44042b8c183b4bf6681c5.png_pic_left]

注：上述方法应该使用当前同步锁对象进行调用。

--------------------

## 五、线程池 ★ ##

### 5.1 线程池概述 ###

线程池就是一个可以复用线程的技术。

不使用线程池存在的问题：如果用户每发起一个请求，后台就创建一个新线程来处理，下次新任务来了又要创建新线程，而创建新线程的开销是很大的，这样会严重影响系统的性能。

工作原理：  
![在这里插入图片描述][c7def5c902a445618ba2750a235ae521.png_pic_left]

--------------------

### 5.2 线程池实现的API ###

JDK 5.0起提供了代表线程池的接口：ExecutorService。

方式一：使用 ExecutorService 的实现类ThreadPoolExecutor 自创建一个线程池对象。

方式二：使用 Executors（线程池的工具类）调用方法返回不同特点的线程池对象。

![在这里插入图片描述][7e12d466245f4791ba19bee36ca57f4a.png_pic_left]

参数说明：

> 参数一：指定线程池的线程数量（核心线程）： corePoolSize，不能小于0  
> 参数二：指定线程池可支持的最大线程数： maximumPoolSize， 最大数量 >= 核心线程数量  
> 参数三：指定临时线程的最大存活时间： keepAliveTime，不能小于0  
> 参数四：指定存活时间的单位(秒、分、时、天)： unit，时间单位  
> 参数五：指定任务队列： workQueue，不能为null  
> 参数六：指定用哪个线程工厂创建线程： threadFactory，不能为null  
> 参数七：策略，指定线程忙，任务满的时候，新任务来了怎么办： handler，不能为null

ExecutorService 的常用方法：  
![在这里插入图片描述][ae47449d84f7441986ab2eb374590856.png_pic_left]  
新任务拒绝策略：

![在这里插入图片描述][490c955baa6c4a94b57d76c2fc2a2f74.png_pic_left]

--------------------

#### 5.2.1 线程池处理Runnable任务 ####

public class MyRunnable implements Runnable{
        
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println(Thread.currentThread().getName() + " 输出了：HelloWorld - " + i);
            }
            try {
        
                System.out.println(Thread.currentThread().getName() + " 线程进入休眠");
                Thread.sleep(3000);
            } catch (Exception e) {
        
                e.printStackTrace();
            }
        }
    }

public class ThreadDemo1 {
        
        public static void main(String[] args) {
        
            // 1. 创建线程池对象：3个核心线程、2个临时线程（5-3）、任务队列容量为 5，表示还可以缓存 5个任务
            // 当核心线程全被占用，任务队列也满，再有任务需要处理时，才会创建临时线程 
            ExecutorService pool = new ThreadPoolExecutor(3, 5, 6, TimeUnit.SECONDS,
                    new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
                    
            // 2. 给任务线程池处理
            Runnable target = new MyRunnable();
            // 一开始若：任务数 > 核心线程数 + 任务队列数，则创建临时线程
            pool.execute(target);
            pool.execute(target);
            pool.execute(target); // 此时三个线程休眠
    
            pool.execute(target); // 进入任务队列
            pool.execute(target);
            pool.execute(target);
            pool.execute(target);
            pool.execute(target); // 不创建临时线程
    
            pool.execute(target); // 创建临时线程
            pool.execute(target); // 创建临时线程
    
            // pool.execute(target); // 拒绝创建
    
            // (了解)关闭线程池
            // pool.shutdownNow(); // 立即关闭，机试任务没有完成，会丢失任务
            // pool.shutdown(); // 会等待全部任务执行完之后再关闭
        }
    }

--------------------

#### 5.2.2 线程池处理 Callable 任务 ####

public class MyCallable implements Callable<String>{
        
        private int n;
        public MyCallable(int n) {
        
            this.n = n;
        }
    
        /**
           2、重写call方法（任务方法）
         */
        @Override
        public String call() throws Exception {
        
            int sum = 0;
            for (int i = 1; i <= n ; i++) {
        
                sum += i;
            }
            return Thread.currentThread().getName()
                    + "执行 1-" + n + "的和，结果是：" + sum;
        }
    }

public class ThreadDemo2 {
        
        public static void main(String[] args) throws Exception {
        
            // 1. 创建线程池对象：3个核心线程、2个临时线程（5-3）、任务队列容量为 5 
            ExecutorService pool = new ThreadPoolExecutor(3, 5, 6, TimeUnit.SECONDS,
                    new ArrayBlockingQueue<>(5), Executors.defaultThreadFactory(), new ThreadPoolExecutor.AbortPolicy());
            // 2. 给任务线程池处理
            Future<String> f1 = pool.submit(new MyCallable(100));
            Future<String> f2 = pool.submit(new MyCallable(100));
            Future<String> f3 = pool.submit(new MyCallable(100));
            Future<String> f4 = pool.submit(new MyCallable(100));
    
            System.out.println(f1.get());
            System.out.println(f2.get());
            System.out.println(f3.get());
            System.out.println(f4.get());
        }
    }

注：Future 是 FutureTask 的 父接口

--------------------

#### 5.2.3 面试题 ####

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

--------------------

### 5.3 Executors工具类实现线程池 ###

得到线程池对象的常用方法：

![在这里插入图片描述][934eec20e13c4930abea504c9047c8eb.png]  
注意：Executors的底层其实也是基于线程池的实现类ThreadPoolExecutor创建线程池对象的。

可能存在的陷阱：大型并发系统环境中使用Executors如果不注意可能会出现系统风险。

![在这里插入图片描述][d0afffce7b97478b9316cbb0aa1cdd9b.png]  
注：OOM 指内存溢出。

![在这里插入图片描述][37c09ca585334b7bbbc72dcdbc9e431d.png_pic_left]

--------------------

文章参考：[Java入门基础视频教程，java零基础自学就选黑马程序员Java入门教程（含Java项目和Java真题）][Java_java_Java_Java_Java]

[9ab67ad4e3bc425aba793f114f37739a.png_pic_left]: https://img-blog.csdnimg.cn/9ab67ad4e3bc425aba793f114f37739a.png#pic_left
[ddafc60ca6ae40fabd6db38561a08186.png_pic_left]: https://img-blog.csdnimg.cn/ddafc60ca6ae40fabd6db38561a08186.png#pic_left
[9281c2064da548cdac3e3b583da3df29.png_pic_left]: https://img-blog.csdnimg.cn/9281c2064da548cdac3e3b583da3df29.png#pic_left
[c3ae3e34495b48e4847193b0315c8e9a.png_pic_left]: https://img-blog.csdnimg.cn/c3ae3e34495b48e4847193b0315c8e9a.png#pic_left
[91353056126b4eeba699de8c0e699fbb.png_pic_left]: https://img-blog.csdnimg.cn/91353056126b4eeba699de8c0e699fbb.png#pic_left
[913337d09c1847ccbae5be41655e0720.png_pic_left]: https://img-blog.csdnimg.cn/913337d09c1847ccbae5be41655e0720.png#pic_left
[7089dc30a78247ce99be836e214fc49e.png_pic_left]: https://img-blog.csdnimg.cn/7089dc30a78247ce99be836e214fc49e.png#pic_left
[705cf32606d84b16901da20751e65b6e.png_pic_left]: https://img-blog.csdnimg.cn/705cf32606d84b16901da20751e65b6e.png#pic_left
[e15ff5784cd748c1a4ba2b838f5e653b.png_pic_left_400x]: https://img-blog.csdnimg.cn/e15ff5784cd748c1a4ba2b838f5e653b.png#pic_left=400x
[4bc9edd2095a4197a37435f2f487f493.png_pic_left]: https://img-blog.csdnimg.cn/4bc9edd2095a4197a37435f2f487f493.png#pic_left
[7d74fa08fb664e76abf89c0e05bc62b4.png_pic_left]: https://img-blog.csdnimg.cn/7d74fa08fb664e76abf89c0e05bc62b4.png#pic_left
[f389b89bc59848daadcc9d1970ea2a13.png]: https://img-blog.csdnimg.cn/f389b89bc59848daadcc9d1970ea2a13.png
[1c4374dfede84ff5b65e5bb1c9ff59b9.png_pic_left]: https://img-blog.csdnimg.cn/1c4374dfede84ff5b65e5bb1c9ff59b9.png#pic_left
[https_blog.csdn.net_weixin_43819566_article_details_128824443]: https://blog.csdn.net/weixin_43819566/article/details/128824443
[9f21207574f44042b8c183b4bf6681c5.png_pic_left]: https://img-blog.csdnimg.cn/9f21207574f44042b8c183b4bf6681c5.png#pic_left
[c7def5c902a445618ba2750a235ae521.png_pic_left]: https://img-blog.csdnimg.cn/c7def5c902a445618ba2750a235ae521.png#pic_left
[7e12d466245f4791ba19bee36ca57f4a.png_pic_left]: https://img-blog.csdnimg.cn/7e12d466245f4791ba19bee36ca57f4a.png#pic_left
[ae47449d84f7441986ab2eb374590856.png_pic_left]: https://img-blog.csdnimg.cn/ae47449d84f7441986ab2eb374590856.png#pic_left
[490c955baa6c4a94b57d76c2fc2a2f74.png_pic_left]: https://img-blog.csdnimg.cn/490c955baa6c4a94b57d76c2fc2a2f74.png#pic_left
[934eec20e13c4930abea504c9047c8eb.png]: https://img-blog.csdnimg.cn/934eec20e13c4930abea504c9047c8eb.png
[d0afffce7b97478b9316cbb0aa1cdd9b.png]: https://img-blog.csdnimg.cn/d0afffce7b97478b9316cbb0aa1cdd9b.png
[37c09ca585334b7bbbc72dcdbc9e431d.png_pic_left]: https://img-blog.csdnimg.cn/37c09ca585334b7bbbc72dcdbc9e431d.png#pic_left
[Java_java_Java_Java_Java]: https://www.bilibili.com/video/BV1Cv411372m/?spm_id_from=333.976.top_right_bar_window_custom_collection.content.click&vd_source=66e56f67ae318dd01461810c59a6e2b5