Java多线程之线程基础（非常详细~）

电玩女神 2023-10-13 12:55 63阅读 0赞

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

*  前言
 *  一、进程和线程的区别
 *  二、并行与并发的区别
 *  三、创建线程的方式（重点）
 *   *  1.继承Thread类
     *  2.实现Runnable接口
     *  3.实现Callable接口
     *  4.使用线程池创建线程
 *  四、Runnable和Callable有什么区别
 *   *  1.Runnable接口的run方法没有返回值
     *  2.Callable接口call方法有返回值，是个泛型
     *  3.Callable接口可以和Future、FutureTask配合使用
     *  4.Callable接口的call()方法允许抛出异常
     *  5.Runnable接口的run()方法不能向上抛
 *  五、线程的几种状态
 *  六、notify()和notifyAll()的区别
 *  七、新建t1、t2、t3三个线程，如何保证他们按顺序执行
 *  八、线程的run()方法和start()方法有什么区别
 *  九、在Java中wait()方法和sleep()方法的区别
 *   *  1.共同点
     *  2.不同点
 *  十、如何停止一个正在运行的线程
 *  十一、一道线程基础笔试题
 *  总结

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

## 前言 ##

多线程是Java中较为难理解的部分，尤其在面试过程中频频被问到，但是我们从来没有系统梳理过多线程包含哪些知识点，那么废话不多说，本篇呢我想结合具体代码案例来梳理一下多线程的基础部分的内容，最后想说一下，这些知识点靠死记硬背真的不行，一定要理解理解理解！！！

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

## 一、进程和线程的区别 ##

![在这里插入图片描述][fe2ce98cb21a48d7beeb312a57375848.png]  
上图是两个应用程序，但还不能叫做进程，当我们双击启动程序，指令给到CPU去执行，同时数据从磁盘加载到内存，此时这种运行中的程序就是进程，而进程又分为单例进程和多例进程，比如记事本可以同事打开多个它就是多例，而酷狗音乐只能打开一个它就是单例的，以上就是进程的定义了，那么进程和线程又是什么关系呢？

>  *  进程是正在运行的程序实例，进程中包含了线程，每个线程执行不同的任务
>  *  不同的进程使用不同的内存空间，在当下进程的所有线程可以共享内存空间
>  *  线程更轻量，线程上下文切换成本一般要比进程上下文切换低（上下文切换指的是从一个线程切换到另一个线程）

## 二、并行与并发的区别 ##

在单核CPU情况下，线程运行其实是串行执行的，我们知道在操作系统内部，CPU是分为一个个时间片给到线程去执行，每个线程执行时间大概为15ms，这对于人类是无法感知的，其实可以这么理解，即宏观并行，微观串行。所以呢，并发可以理解为多个线程轮流使用CPU的现象。那么并行与并发到底有什么区别呢？举个简单的例子，一个家庭主妇同时要做很多事情，她要给婴儿喂奶、要打扫卫生、还要做饭，她一个人轮流交替做这些事情就是并发。再举一个例子，比如这位家庭主妇雇了一位保姆，他们一起做这些事，这时既有并行也有并发（这时会产生竞争，锅只有一口，一人用锅时另一人只能等待），如果这个家庭主妇雇了三个保姆，一个专做饭，一个专打扫卫生，一个专喂奶，互不干扰这时就是并行。总结如下：

>  *  并发是同一时间应对多件事的能力，多个线程轮流使用一个或多个CPU
>  *  并行是同一时间动手做多件事的能力，4核CPU同时执行4个线程

## 三、创建线程的方式（重点） ##

>  *  通过继承Thread类来创建线程
>  *  通过实现Runnable接口来创建线程
>  *  通过实现Callable接口来创建线程
>  *  通过线程池创建线程（工作中常用的方式）

下面，我们通过代码的方式了解一下这几种创建线程的方式

### 1.继承Thread类 ###

public class MyThread extends Thread{
        
        @Override
        public void run() {
        
            System.out.println("Mythread run...");
        }
    
        public static void main(String[] args) {
        
            MyThread thread01 = new MyThread();
            thread01.start();
        }
    }

### 2.实现Runnable接口 ###

public class MyRunnable implements Runnable{
        
    
        @Override
        public void run() {
        
            System.out.println("MyRunnable is running...");
        }
    
        public static void main(String[] args) {
        
            MyRunnable myRunnable = new MyRunnable();
            Thread thread = new Thread(myRunnable);
            thread.start();
        }
    }

这里我们注意的是，我们需要先创建实现Runnable接口的类对象，然后把对象传入到Thread构造方法中，才可以运行

### 3.实现Callable接口 ###

public class MyCallable implements Callable<String> {
        
        @Override
        public String call() throws Exception {
        
            System.out.println(Thread.currentThread().getName());
            return "OK";
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            MyCallable myCallable = new MyCallable();
            FutureTask<String> futureTask = new FutureTask<>(myCallable);
            Thread thread = new Thread(futureTask);
            thread.start();
            System.out.println("线程运行后的返回结果：" + futureTask.get());
        }
    
    }

这里我们可以结合FutureTask获取线程异步执行的结果，这也是Callable和Runnable创建线程的一个区别，后面会提到

### 4.使用线程池创建线程 ###

public class MyExecutors implements Runnable{
        
        @Override
        public void run() {
        
            try{
        
                System.out.println("MyExecutors is running...");
            }catch (Exception e){
        }
        }
    
        public static void main(String[] args) {
        
            // 创建线程池对象
            ExecutorService threadPool = Executors.newFixedThreadPool(3);
            threadPool.submit(new MyExecutors());
            // 关闭线程池
            threadPool.shutdown();
        }
    }

## 四、Runnable和Callable有什么区别 ##

### 1.Runnable接口的run方法没有返回值 ###

![在这里插入图片描述][24af617ab24a4febbd0d46efd51bd7a9.png]  
我们可以看到Runnable接口的方法返回值是void类型

### 2.Callable接口call方法有返回值，是个泛型 ###

![在这里插入图片描述][85bce1c214d9456c998576bef8247498.png]

### 3.Callable接口可以和Future、FutureTask配合使用 ###

Callable接口和Future、FutureTask配合使用可以用来获取异步执行的结果，通过future.get()方法可以获取线程执行结果。  
![在这里插入图片描述][2682da6fd48b4187ae485210264541d7.png]

### 4.Callable接口的call()方法允许抛出异常 ###

![在这里插入图片描述][3f574a1e8b1f4f989d7b50703e15acc6.png]

### 5.Runnable接口的run()方法不能向上抛 ###

![在这里插入图片描述][8d1b5d6204794f4992ee3d41e02e08f0.png]  
在编译阶段就报错了，可见run()方法不能抛出异常，但是可以使用try-catch内部消化  
![在这里插入图片描述][5d4c1de4cb03403196d5e352dff501ff.png]

## 五、线程的几种状态 ##

我们可以打开Thread类，此类中定义了一个内部枚举类，描述了线程自创建至消亡的几种状态  
![在这里插入图片描述][cd178044059e4d6e9701ae1413e6e48b.png]  
从以上定义我们可以看出它一共有6种状态，分别是：

> 新建（NEW）、可运行（RUNNABLE）、阻塞（BLOCKED）、等待（WAITING）、时间等待（TIMED\_WAITING）、终止（TERMINATED）

其实我们可以简化一下，更好理解一点，从new一个线程，就是新建，当我们调用线程的start()方法，它就是可运行状态，线程运行完后就是终止状态，而可运行状态又分为可运行、阻塞、等待、以及时间等待状态，这些状态不就是因为调用了sleep()方法或者wait()方法或者在加synchronized锁的情况下没有获取锁的时候嘛，看下图我们可以更清晰直观的理解这些状态背后的原理：  
![在这里插入图片描述][cbd31ddfb56a431e98e2586d25165c9a.png]  
那么总结一下，线程之间状态的切换过程如下：

>  *  创建线程对象是新建状态
>  *  调用了start()方法变为可执行状态
>  *  线程获取到了CPU的执行权，执行结束是终止状态
>  *  在可执行状态过程中，如果没有获取到CPU的执行权，可能会切换其他状态（阻塞、等待、计时等待）
>  *  如果没有获取锁，那么此时会进入阻塞状态，获得锁后再切换为可执行状态
>  *  如果线程调用了wait()方法进入等待状态，其他线程调用了notify()唤醒后可切换为可执行状态
>  *  如果线程调用了sleep(50)方法，进入计时等待状态，到了时间后可切换为可执行状态

## 六、notify()和notifyAll()的区别 ##

这个其实比较容易理解，见名知意

>  *  notify：之随机唤醒一个线程
>  *  notifyAll：唤醒所有wait线程  
>     放一个案例，代码只粘贴一次，分别调用对象的notify(）和notifyAll(）方法，看执行结果就可以知道

public class WaitNotify {
        
        static Object obj = new Object();
        public static void main(String[] args) throws InterruptedException{
        
            // create t1 thread
            Thread t1 = new Thread(()->{
        
                synchronized (obj){
        
                    try {
        
                        System.out.println("t1 is start...");
                        obj.wait();
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                    System.out.println("t1被唤醒了...");
                }
            }, "t1");
            // create t2 thread
            Thread t2 = new Thread(()->{
        
                synchronized (obj){
        
                    try {
        
                        System.out.println("t2 is start...");
                        obj.wait();
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                    System.out.println("t2被唤醒了...");
                }
            }, "t2");
            // 主线程
            t1.start();
            t2.start();
            // 主线程睡眠
            Thread.sleep(3000);
            // 主线程获取对象锁
            synchronized (obj){
        
                // 随机唤醒一个线程
               obj.notify();
                // 唤醒所有线程
                //obj.notifyAll();
            }
    
        }
    }

我们分析一下上面的代码，我们在主方法中创建了两个线程，分别是t1和t2，两个线程中都使用了同一个synchronized对象锁，主线程也使用了和上面两个线程一样的对象锁，当调用两个线程的start()方法时，不管哪个线程先执行，这两句都会输出（t1 is start…、t2 is start…）因为一个线程获取了对象锁之后，立刻又调用了wait()方法进入等待状态，那么另一个线程就可以获取这个对象锁，那么等主线程睡眠了3s后主线程拿到了对象锁，调用了对象的notify(）方法随机唤醒了其中一个线程。我们看看执行结果：  
![在这里插入图片描述][ba2d9d162f40459492a29abc941b14d4.png]  
我们发现程序并没有退出，因为此时只唤醒了t1线程，而t2线程还处于运行状态

当我们调用对象的notifyAll()方法时，就会唤醒所有处于wait状态的线程，看程序运行结果：  
![在这里插入图片描述][014d618ceb384742981b116c2378d8fd.png]  
![在这里插入图片描述][222b612b58d54b6bbdd07c705c4fba27.png]  
我们可以看到程序已经停止了，说明两个线程都已经执行完毕，没有处于等待状态的线程

## 七、新建t1、t2、t3三个线程，如何保证他们按顺序执行 ##

>  *  可以使用线程中的join()方法解决
>  *  t.join()阻塞调用此方法的线程进入计时等待状态，直到线程t执行完后，此线程再继续执行

代码如下：

public class JoinTest {
        
        public static void main(String[] args) {
        
            Thread t1 = new Thread(()->{
        
                try{
        
                    System.out.println("t1 is start...");
                }catch (Exception e){
        }
            });
    
            Thread t2 = new Thread(()->{
        
               try{
        
                   t1.join();
               }catch (Exception e){
        }
                System.out.println("t2 is start...");
            });
    
            Thread t3 = new Thread(()->{
        
                try{
        
                    t2.join();
                }catch (Exception e){
        }
                System.out.println("t3 is start...");
            });
            t3.start();
            t2.start();
            t1.start();
        }
    }

以上代码中，我们创建了三个线程，分别是t1、t2、t3，在t2中调用了t1的join()方法，在t3中调用了t2的join()方法，因此无论哪个线程的start()写在前面，线程的执行顺序必然是t1>t2>t3  
程序运行结果如下：  
![在这里插入图片描述][ff7b98acdad2440b8e08732d2d841102.png]

## 八、线程的run()方法和start()方法有什么区别 ##

你们在面试中有没有经常遇到这个问题，其实很基础，但是我们通常回答的不是那么令自己满意，这里我们简单总结一下，另外通过程序简单运行看出两者的区别：

>  *  start() ：用来启动线程，通过该线程调用run()方法中定义的逻辑代码。start()方法只能被调用一次
>  *  run()：封装了要被线程执行的代码，可以被调用多次

public class StartAndRunTest {
        
        public static void main(String[] args) {
        
            Thread t1 = new Thread("t1"){
        
                @Override
                public void run() {
        
                    System.out.println("t1 is running...");
                }
            };
            t1.start();
            t1.run();
            t1.run();
    //        t1.start();
        }
    }

对于效果上我们调用start()方法和run()方法是一样的，都会执行run方法体中的代码，看运行结果：  
![在这里插入图片描述][11c333ef354c4badae28f818be864e49.png]  
当我们执行多次start()方法时，就会抛出异常  
![在这里插入图片描述][ddc07eff56884dbfb03035ee9aa403ae.png]  
![在这里插入图片描述][6bcd907301024f6093d46b5e67369ea7.png]

## 九、在Java中wait()方法和sleep()方法的区别 ##

这个也是经常被问到的问题，我们能回答全嘛，他们有共同点也有不同点，先总结一下：

### 1.共同点 ###

>  *  wait()、wait(long)和sleep(long)的效果都是让当前线程暂时放弃CPU的使用权，进入阻塞状态

### 2.不同点 ###

>  *  方法归属不同，sleep(long)是Thread的静态方法，而wait()，wait(long)都是Object()的成员方法，每个对象都有
>  *  醒来时机不同，执行sleep(long)和wait(long)的线程都会在等待相应毫秒后醒来，wait(long)和wait()还可以被notify还可以被notify()唤醒，wait()如果不唤醒就会一直等待下去，他们都可以被打断唤醒
>  *  锁特性不同（重点）wait()方法的调用必须先获取到wait()对象的锁，而sleep则无此限制，wait()方法执行后会释放对象锁，允许其他线程获得该对象锁（我放弃CPU，但你们还可以使用）而sleep如果在synchronized代码块中执行，并不会释放对象锁（我放弃CPU，你们也用不了）

文字描述比较难理解，我们可以分析具体案例来理解以上的概念：

public class WaitSleepCase {
        
        static final Object LOCK = new Object();
    
        public static void main(String[] args) throws InterruptedException {
        
            illegalWait();
        }
    
        /**
         * @throws InterruptedException
         */
        private static void illegalWait() throws InterruptedException {
        
            synchronized (LOCK){
        
                System.out.println("LOCK is waiting");
                LOCK.wait();
            }
        }
    }

以上我们定义了一个illegalWait方法，在方法体中使用了synchronized代码块，在代码块中调用了对象的wait()方法看程序运行结果：  
![在这里插入图片描述][42699d169cad4eec9bb6115e30804fe6.png]  
程序正常运行没毛病，进程也没有停止，因为线程处于wait状态，并没有被唤醒。  
![在这里插入图片描述][79ec3c778f2344a981ff15bddf36aab1.png]  
![在这里插入图片描述][38492b92ef7a4c92820fb448b36cfd02.png]  
如果我们不在synchronized中调用wait()方法就会报异常！  
接下来我们继续看另一个案例：

public class WaitSleepCase {
        
        static final Object LOCK = new Object();
    
        public static void main(String[] args) throws InterruptedException {
        
            waiting();
        }
    
        private static void waiting() throws InterruptedException {
        
            Thread t1 = new Thread(()->{
        
                synchronized (LOCK){
        
                    try {
        
                        System.out.println("t1 is waiting...");
                        LOCK.wait(5000L);
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                    System.out.println("t1 is running and end...");
                }
            }, "t1");
    
            t1.start();
            Thread.sleep(100);
            synchronized (LOCK){
        
                System.out.println("主线程获取了锁...");
            }
        }
      }

在以上代码中我们定义了waiting方法，方法中我们创建了线程t1,线程t1中使用了synchronized代码块，并调用了对象的wait(5000L)方法，线程t1启动后，获取到对象锁，然后会睡眠5s，主线程睡眠0.1s然后主线程获取到了对象锁，并打印了语句，最后，过了5s后，线程t1获取了对象锁，最后退出  
执行结果如下：  
![在这里插入图片描述][e890fe8b1ccf4ada9332127eb09ea489.png]  
最后一个案例

public class WaitSleepCase {
        
        static final Object LOCK = new Object();
    
        public static void main(String[] args) throws InterruptedException {
        
            sleeping();
        }
    
        private static void sleeping() throws InterruptedException {
        
            Thread t2 = new Thread(()->{
        
                synchronized (LOCK){
        
                    try {
        
                        System.out.println("t2 is start...");
                        Thread.sleep(5000L);
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
                    System.out.println("t2 is running and end...");
                }
            },"t2");
            t2.start();
            Thread.sleep(300);
            synchronized (LOCK){
        
                System.out.println("主线程获取了对象锁...");
            }
        }
      }

以上代码定义了一个sleeping方法，创建了t2线程，线程中同样使用了synchronized代码块，代码块中使用了Thread的静态方法sleep(5000L)，t2线程启动后，t2线程获取对象锁，然后睡眠5s中，他与wait(5000L)的区别在于，他睡眠的5s期间，任何其他线程都拿不到这个对象锁，因此主线程是拿不到对象锁的，除非5s之后，线程t2释放对象锁，主线程又可以获取到对象锁。  
运行结果如下：  
![在这里插入图片描述][3c3e8e11f5e74a438940db556f728714.png]

## 十、如何停止一个正在运行的线程 ##

>  *  使用退出标志，使线程正常退出，也就是当run方法完成后线程终止

public class MyInterrupt1 extends Thread{
        
        volatile boolean flag = false;
    
        @Override
        public void run() {
        
            while (!flag){
        
                System.out.println("MyThread...running...");
                try {
        
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
        
        public static void main(String[] args) throws InterruptedException {
        
            // 启动线程
            MyInterrupt1 myInterrupt1 = new MyInterrupt1();
            myInterrupt1.start();
            // 线程睡眠6000ms
            Thread.sleep(6000L);
            // 改变boolean类型值为true
            myInterrupt1.flag = true;
        }
    }

我们定义了一个布尔类型的标志，使用volatile关键字修饰，表示共享变量的修改对于线程间是可见的，我们使用继承Thread类的方式创建了一个线程，在线程的run方法中，使用了一个while循环，条件是!flag，因为初始值是false，如果不被修改的话，这就是个死循环，在主线程中在睡眠6s后，将boolean类型的flag修改为true，那么线程run()方法就会退出while循环，从而线程结束运行。运行结果如下：  
![在这里插入图片描述][ce0403fff3124e3db0217bf6e8aa194d.png]

>  *  使用stop方法强行终止（不推荐，方法已作废）

public class MyInterrupt2 extends Thread{
        
        volatile boolean flag = false;
    
        @Override
        public void run() {
        
            while (!flag){
        
                System.out.println("MyThread...running...");
                try {
        
                    Thread.sleep(3000L);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            // 启动线程
            MyInterrupt2 myInterrupt1 = new MyInterrupt2();
            myInterrupt1.start();
            // 线程睡眠6000ms
            Thread.sleep(6000L);
            // 调用stop方法
            myInterrupt1.stop();
        }
    }

这个代码跟上面的代码基本没什么区别，只是多了一个调用stop()方法，我们看一下运行结果：  
![在这里插入图片描述][6255448394ad4a8d9973c1b97d71d5c5.png]

>  *  使用interrupt方法中断线程，打断阻塞的线程（sleep，wait，join）的线程会抛出InterruptedException异常，打断正常的线程，可以根据打断状态来标记是否退出线程

接下来我们看另一种中断线程的方式，通过调用interrupt方法中断线程

public class MyInterrupt3 {
        
        public static void main(String[] args) throws InterruptedException {
        
            // 打断sleep状态线程
            Thread t1 = new Thread(()->{
        
                System.out.println("t1...running...");
                try {
        
                    Thread.sleep(5000L);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }, "t1");
            // 启动t1线程
            t1.start();
            // 主线程睡眠
            Thread.sleep(500L);
            // 调用interrupt方法中断线程
            t1.interrupt();
            // 中断后的状态
            System.out.println(t1.isInterrupted());
    }
    }

运行结果如下：  
![在这里插入图片描述][508469f955fe49a9a9d9165534fc5c97.png]

public class MyInterrupt3 {
        
        public static void main(String[] args) throws InterruptedException {
        
            //打断正常状态线程
            Thread t2 = new Thread(()->{
        
                while (true){
        
                    System.out.println("t2...running...");
                    Thread thread = Thread.currentThread();
                    boolean interrupted = thread.isInterrupted();
                    if (interrupted){
        
                        System.out.println("打断状态：" + interrupted);
                        break;
                    }
                }
            }, "t2");
    
            // 启动t2线程
            t2.start();
            // 主线程睡眠
            Thread.sleep(500L);
            // 打断t2线程
            t2.interrupt();
    }
    }

运行结果如下：  
![在这里插入图片描述][324e29942ea745ab816d125c1b383b46.png]

## 十一、一道线程基础笔试题 ##

不久前刷到的一道笔试题，看小伙伴们有没有什么思路，可以将答案打在评论区，代码如下：

public class ThreadExample {
        
    
        public static void main(String[] args) throws InterruptedException {
        
            StringBuilder str = new StringBuilder();
            Thread t1 = new Thread(()->{
        
               synchronized (str){
        
                   str.append("A");
                   try{
        
                       str.wait(3 * 1000);
                   }catch (InterruptedException e){
        
                       // ignore
                   }
                   str.append("B");
               }
            });
    
            Thread t2 = new Thread(()->{
        
               synchronized (str){
        
                   str.append("C");
                   str.notify();
                   str.append("D");
               }
            });
    
            t1.start();
            Thread.sleep(300);
            t2.start();
    
            t1.join();
            t2.join();
            System.out.println(str.toString());
    
        }
    }

问题是最后str.toString()打印出来是什么？，我们可以在评论区讨论一下…

## 总结 ##

本篇多线程基础知识较多，阅读的小伙伴如果基础和本人一样比较薄弱，建议可以手敲一变，边理解边记忆，这样效果会好很多，描述过程中如有漏洞请批评指针，写这篇博客花了几个小时时间实属不易，应对面试不是最终目的，对于编程事业是一生的事情，下一篇将会介绍线程并发中的知识点。

[fe2ce98cb21a48d7beeb312a57375848.png]: https://img-blog.csdnimg.cn/fe2ce98cb21a48d7beeb312a57375848.png
[24af617ab24a4febbd0d46efd51bd7a9.png]: https://img-blog.csdnimg.cn/24af617ab24a4febbd0d46efd51bd7a9.png
[85bce1c214d9456c998576bef8247498.png]: https://img-blog.csdnimg.cn/85bce1c214d9456c998576bef8247498.png
[2682da6fd48b4187ae485210264541d7.png]: https://img-blog.csdnimg.cn/2682da6fd48b4187ae485210264541d7.png
[3f574a1e8b1f4f989d7b50703e15acc6.png]: https://img-blog.csdnimg.cn/3f574a1e8b1f4f989d7b50703e15acc6.png
[8d1b5d6204794f4992ee3d41e02e08f0.png]: https://img-blog.csdnimg.cn/8d1b5d6204794f4992ee3d41e02e08f0.png
[5d4c1de4cb03403196d5e352dff501ff.png]: https://img-blog.csdnimg.cn/5d4c1de4cb03403196d5e352dff501ff.png
[cd178044059e4d6e9701ae1413e6e48b.png]: https://img-blog.csdnimg.cn/cd178044059e4d6e9701ae1413e6e48b.png
[cbd31ddfb56a431e98e2586d25165c9a.png]: https://img-blog.csdnimg.cn/cbd31ddfb56a431e98e2586d25165c9a.png
[ba2d9d162f40459492a29abc941b14d4.png]: https://img-blog.csdnimg.cn/ba2d9d162f40459492a29abc941b14d4.png
[014d618ceb384742981b116c2378d8fd.png]: https://img-blog.csdnimg.cn/014d618ceb384742981b116c2378d8fd.png
[222b612b58d54b6bbdd07c705c4fba27.png]: https://img-blog.csdnimg.cn/222b612b58d54b6bbdd07c705c4fba27.png
[ff7b98acdad2440b8e08732d2d841102.png]: https://img-blog.csdnimg.cn/ff7b98acdad2440b8e08732d2d841102.png
[11c333ef354c4badae28f818be864e49.png]: https://img-blog.csdnimg.cn/11c333ef354c4badae28f818be864e49.png
[ddc07eff56884dbfb03035ee9aa403ae.png]: https://img-blog.csdnimg.cn/ddc07eff56884dbfb03035ee9aa403ae.png
[6bcd907301024f6093d46b5e67369ea7.png]: https://img-blog.csdnimg.cn/6bcd907301024f6093d46b5e67369ea7.png
[42699d169cad4eec9bb6115e30804fe6.png]: https://img-blog.csdnimg.cn/42699d169cad4eec9bb6115e30804fe6.png
[79ec3c778f2344a981ff15bddf36aab1.png]: https://img-blog.csdnimg.cn/79ec3c778f2344a981ff15bddf36aab1.png
[38492b92ef7a4c92820fb448b36cfd02.png]: https://img-blog.csdnimg.cn/38492b92ef7a4c92820fb448b36cfd02.png
[e890fe8b1ccf4ada9332127eb09ea489.png]: https://img-blog.csdnimg.cn/e890fe8b1ccf4ada9332127eb09ea489.png
[3c3e8e11f5e74a438940db556f728714.png]: https://img-blog.csdnimg.cn/3c3e8e11f5e74a438940db556f728714.png
[ce0403fff3124e3db0217bf6e8aa194d.png]: https://img-blog.csdnimg.cn/ce0403fff3124e3db0217bf6e8aa194d.png
[6255448394ad4a8d9973c1b97d71d5c5.png]: https://img-blog.csdnimg.cn/6255448394ad4a8d9973c1b97d71d5c5.png
[508469f955fe49a9a9d9165534fc5c97.png]: https://img-blog.csdnimg.cn/508469f955fe49a9a9d9165534fc5c97.png
[324e29942ea745ab816d125c1b383b46.png]: https://img-blog.csdnimg.cn/324e29942ea745ab816d125c1b383b46.png