Java 创建线程读这一篇就够了

我不是女神ヾ 2023-06-20 06:14 15阅读 0赞

### 文章目录 ###

*  java 多线程
 *   *  线程创建两种方式
     *  创建线程
     *   *  模拟排队机叫号排队
     *  线程生命周期
     *  线程中一些常用方法
     *   *  构造方法
         *   *  Runable 参数传值null
             *  ThreadGroup 值，默认传值为null
             *  获取运行线程数量
             *  参数 stackSize
             *  设置守护线程
             *  线程优先级
             *  线程id
             *  join方法
         *  打断线程
         *   *  方法一
             *  方法二
             *  方法三

# java 多线程 #

## 线程创建两种方式 ##

*  集成Thread 类
 *  实现Runable接口

两种方式都需要重写run方法

启动线程调用start()方法

## 创建线程 ##

这里继承Thread 创建线程实例

public class ThreadStart { 
    
    
        /** * java 应用程序的main函数是一个线程，是被jvm启动的时候调用，线程名字叫main * * 实现一个线程，必须创建Thread实例，重写 run方法，并且调用start方法 * 在jvm启动后，实际上有多个线程，但是至少有一个非守护线程 main 入口启动线程 * 当调用一个线程启动start方法的时候， 此时至少用两个线程，一个是调用你的线程 还是有一个是执行run的线程 * * 线程的生命周期 分为 new Thread,runnbale,running,bloic,terminated * * 注意： * start 之后不可能立即进入 running 先处于 runnbale * bloic 之后 必须先回到 runnbale 再回到 running，过程中可能挂掉 处于 terminated * */
        public static void main(String[] args) { 
    
            //main方法线程名称
            System.out.println(Thread.currentThread().getName());
    
            Thread t1 = new Thread(){ 
    
                @Override
                public void run() { 
                    //t1线程名称
                    System.out.println(Thread.currentThread().getName());
                }
            };
    
            //启动线程 不是run方法 在源码中 将逻辑方法都抽象到run方法中，在start方法中 启动run方法，这样子可以通过重写来定义自己的业务逻辑
            t1.start();
        }
    }

### 模拟排队机叫号排队 ###

创建线程

public class ThreadBank1 { 
    
    
        public static void main(String[] args) { 
            BnakThread t1 = new BnakThread();
            BnakThread t2 = new BnakThread();
            BnakThread t3 = new BnakThread();
    
    		//启动
            t1.start();
            t2.start();
            t3.start();
    
    
        }
    }
    
    
    class BnakThread extends Thread { 
    
    
        int num = 1;
        int max = 50;
    
        @Override
        public void run() { 
            while (num<=max){ 
                System.out.println(Thread.currentThread() + " 的号码是 " + num );
                num++;
            }
        }
    }

结果如下

仅一部分数据  
![仅一部分][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70]

这样虽然启动线程打印出结果，但是存在一个问题，这样三个排队机 互相各玩各的,三个排队机都将50个号码打印一个遍。

`数据没有做到共享`

解决办法1：

*  可以设置静态变量

static int num = 1;
       static int max = 50;

*  可以使用runnable接口将逻辑从线程中分离出来

也就是创建现成的第二种方式实现Runable接口

定义一个类实现runnable接口

package com.company;
    
    /** * @description: 模拟叫号排队 * @author: Administrator * @create: 2019-12-08 13:32 **/
    public class ThreadRunnableBank2 { 
    
    
        public static void main(String[] args) { 
    
            BnakRunable runable = new BnakRunable();
    
            Thread t1 = new Thread(runable,"1号");
            Thread t2 = new Thread(runable,"2号");
            Thread t3 = new Thread(runable,"3号");
    
            //start
    
            t1.start();
            t2.start();
            t3.start();
    
    
        }
    }
    
    
    class BnakRunable implements Runnable { 
    
    
       static int num = 1;
        static int max = 50;
    
        @Override
        public void run() { 
            while (num<=max){ 
                System.out.println(Thread.currentThread() + " 的号码是 " +  num++ );
                try { 
                    Thread.sleep(100);
                } catch (InterruptedException e) { 
                    e.printStackTrace();
                }
    
            }
        }
    }

可以看到结果如下

Thread[1号,5,main] 的号码是 1
    Thread[3号,5,main] 的号码是 2
    Thread[2号,5,main] 的号码是 3
    Thread[1号,5,main] 的号码是 4
    Thread[3号,5,main] 的号码是 4
    Thread[2号,5,main] 的号码是 5
    Thread[1号,5,main] 的号码是 6
    Thread[3号,5,main] 的号码是 7
    Thread[2号,5,main] 的号码是 8
    Thread[3号,5,main] 的号码是 9
    Thread[1号,5,main] 的号码是 9
    Thread[2号,5,main] 的号码是 10
    Thread[1号,5,main] 的号码是 11
    Thread[3号,5,main] 的号码是 12
    Thread[2号,5,main] 的号码是 13
    Thread[3号,5,main] 的号码是 14
    Thread[1号,5,main] 的号码是 15
    Thread[2号,5,main] 的号码是 16
    Thread[3号,5,main] 的号码是 17
    Thread[1号,5,main] 的号码是 17
    Thread[2号,5,main] 的号码是 18
    Thread[1号,5,main] 的号码是 19
    Thread[3号,5,main] 的号码是 20
    Thread[2号,5,main] 的号码是 21
    Thread[3号,5,main] 的号码是 22
    Thread[1号,5,main] 的号码是 23
    Thread[2号,5,main] 的号码是 24
    Thread[3号,5,main] 的号码是 25
    Thread[1号,5,main] 的号码是 25
    Thread[2号,5,main] 的号码是 26
    Thread[3号,5,main] 的号码是 27
    Thread[1号,5,main] 的号码是 27
    Thread[2号,5,main] 的号码是 28
    Thread[3号,5,main] 的号码是 29
    Thread[1号,5,main] 的号码是 29
    Thread[2号,5,main] 的号码是 30
    Thread[1号,5,main] 的号码是 31
    Thread[3号,5,main] 的号码是 31
    Thread[2号,5,main] 的号码是 32
    Thread[1号,5,main] 的号码是 33
    Thread[3号,5,main] 的号码是 33
    Thread[2号,5,main] 的号码是 34
    Thread[3号,5,main] 的号码是 35
    Thread[1号,5,main] 的号码是 36
    Thread[2号,5,main] 的号码是 37
    Thread[3号,5,main] 的号码是 38
    Thread[1号,5,main] 的号码是 38
    Thread[2号,5,main] 的号码是 39
    Thread[3号,5,main] 的号码是 41
    Thread[1号,5,main] 的号码是 40
    Thread[2号,5,main] 的号码是 42
    Thread[3号,5,main] 的号码是 44
    Thread[1号,5,main] 的号码是 43
    Thread[2号,5,main] 的号码是 45
    Thread[3号,5,main] 的号码是 46
    Thread[1号,5,main] 的号码是 46
    Thread[2号,5,main] 的号码是 47
    Thread[1号,5,main] 的号码是 48
    Thread[3号,5,main] 的号码是 48
    Thread[2号,5,main] 的号码是 49
    Thread[1号,5,main] 的号码是 50
    Thread[3号,5,main] 的号码是 50

Runable的作用是将可执行的代码逻辑从线程中分离出来，这比较符合我们的面向对象思想。

## 线程生命周期 ##

线程生命周期图例如下图  
![图片来自网络][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 1]

大致分为以下及格过程

*  1 new Thread() 创建线程
 *  2 然后调用start()方法进入 runnable可执行状态，runbale也可能出现异常线程进入terminated 状态
 *  3 可执行状态阶段争抢cpu ，抢到了cpu执行调度权进入running状态，如果没有抢到执行cpu 线程继续处于runbale状态
 *  4 running过程中 可能存在 wait , sleep 等 让线程处于bolck状态
 *  bolck 状态结束后 ，线程进入可执行 runnable 状态,然后 runnable 继续执行第3阶段步骤；  
    也可能出现异常，进入 terminated 死亡结束状态；
 *

## 线程中一些常用方法 ##

创建对象Thread的时候，默认会有一个线程名，以Thread-开头，从0开始计数

### 构造方法 ###

new Thread();

Thread-0  
Thread-1  
Thread-2

public static void main(String[] args) { 
    
            Thread t0 = new Thread();
            System.out.println(t0.getName());
    
    
            Thread t1 = new Thread(){ 
    
                @Override
                public void run() { 
                    //t1线程名称
                    Thread.currentThread().setName("线程2");
                    System.out.println(Thread.currentThread().getName());
                }
            };
    
            t1.start();
            t0.start();
        }

可以看到默认是以0开头的  
![在这里插入图片描述][20191208155749689.png]

`通过源码可以看到具体缘由`

“Thread-” + nextThreadNum() Thread开头 然后+ nextThreadNum()方法

public Thread() { 
            init(null, null, "Thread-" + nextThreadNum(), 0);
        }

nextThreadNum() 方法 静态方法提供递增操作

private static synchronized int nextThreadNum() { 
            return threadInitNumber++;
        }

也可以看到当构造方法里什么都不传值的话 调用默认的init初始化方法

#### Runable 参数传值null ####

init(null, null, "Thread-" + nextThreadNum(), 0);

Runable 赋值成员变量  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 2]  
然后start开启线程执行run方法  
调用本地方法  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 3]

本地run执行方法内容，可以看到 上面穿的值默认为null 所以没有任何线程内容输出。  
![在这里插入图片描述][2019120816051929.png]

> 所以定义线程时候，要重写run方法实现自己业务逻辑

#### ThreadGroup 值，默认传值为null ####

**如果没有传入 ThreadGroup 值，默认传值为null**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 4]

会获取父线程的ThreadGroup 作为该线程的ThreadGroup ，此时子线程和父线程将会在同一个ThreadGroup 里。  
可以通过ThreadGroup 查看到 线程的运行数量等

//t1线程ThreadGroup名
    System.out.println(t1.getThreadGroup().getName()); //main
    //main 的ThreadGroup名
    System.out.println(Thread.currentThread().getThreadGroup().getName());//main

#### 获取运行线程数量 ####

//获取到 ThreadGroup 中有多少个线程在运行
            System.out.println(Thread.currentThread().getThreadGroup().activeCount()); //理想情况下是2个

#### 参数 stackSize ####

stackSize 默认是0 表示跟平台有关，个人电脑配置内存大小和jvm内存大小有关

stackSize 参数表示意思是当前线程虚拟机栈帧大小

方法在调用的时候当前栈的大小决定方法可以进行压栈进栈多少次，如果超过这个次数会抛出 StackOverflowError 错误信息

通常默认情况下main方法栈帧，也就是jvm启动时候创建的栈帧大小即虚拟机栈

//计数器
        private static int count;
        /** * 线程名 * @param args */
        public static void main(String[] args) { 
    
            //main方法是jvm启动时候创建的 虚拟机栈帧大小是 49799 
            //main方法 中调用add方法压栈进栈 次数为 49799 次
    
           try { 
                add(1);
            }catch (Error e){ 
                e.getMessage();
                System.out.println(count);
            }
              
          
        }
    
    
        /** * 递归调用 * @param i */
        static void add(int i){ 
            ++count;
            add(i+1);
        }

结果

> java.lang.StackOverflowError  
> 49799

线程设置栈帧大小

根据构造函数传参

![>][20191208170213116.png]  
线程设置栈帧大小

public static void main(String[] args) { 
    
            Thread thread = new Thread(null, new Runnable() { 
                @Override
                public void run() { 
                    try { 
                        add(1);
                    }catch (Error e){ 
                        System.out.println(e.getClass().getName());
                        System.out.println(count);
                    }
                }
            },"test",1<<24); // 栈帧 1<<24 次
    
            thread.start();
        }
    
    
        /** * 递归调用 * @param i */
        static void add(int i){ 
            ++count;
            add(i+1);
        }
    }

结果

> java.lang.StackOverflowError  
> 418012

#### 设置守护线程 ####

/** * 守护线程 随着父线程结束而结束 * @param args */
        public static void main(String[] args) { 
    
    
            Thread thread = new Thread(null, new Runnable() { 
                @Override
                public void run() { 
    
                    System.out.println("test 线程 ");
                }
            },"test");
    
    
            /** * 设置为true时候 控制台只打印main test 线程随着main线程结束而退出 * 设置为true时候 "test 线程 " 会打印 */
            thread.setDaemon(false); //默认是false
            thread.start();
    
    
            System.out.println("mian ");
        }

结果  
![在这里插入图片描述][20191208174446499.png]

设置守护线程时候 必须在启动线程之前设置，不然会抛出异常 `java.lang.IllegalThreadStateException`

#### 线程优先级 ####

void setPriority(int newPriority)

newPriority 默认是5 范围 1- 10最高级10和最低级1 ； 一般情况下 数字越大优先级越高

#### 线程id ####

System.out.println(Thread.currentThread().getId()); //1 main线程由jvm 优先启动
            System.out.println(thread2.getId()); //11
            System.out.println(thread.getId()); //12

源码

public long getId() { 
            return tid;
        }

![在这里插入图片描述][20191208180944256.png]  
获取下一个线程id 值递增

private static synchronized long nextThreadID() { 
            return ++threadSeqNumber;
        }

#### join方法 ####

join方法的主要作用就是同步，它可以使得线程之间的并行执行变为串行执行。在A线程中调用了B线程的join()方法时，表示只有当B线程执行完毕时，A线程才能继续执行。

例如：  
在mian线程中启动一个线程

public class ThreadJoin { 
    
    
        public static void main(String[] args) throws InterruptedException { 
    
            Thread thread1 = new Thread(null, new Runnable() { 
                @Override
                public void run() { 
                    for (int i =1;i<=100;i++){ 
                        System.out.println(" test1 - > " + i);
                    }
                }
            },"test1");
    
            thread1.start();
            //thread1.join();
            
            System.out.println(" main 线程中 打印输出 。。。");
            for (int i =1;i<=100;i++){ 
                System.out.println(" main - > " + i);
            }
        }
    
    
    
    }

在没有使用 join（）方法之前，main线程启动 ，main中启动完线程 thread1 之后main线程中打印方法 和 线程thread1 打印 一起并行。结果如下图所示：  
![在这里插入图片描述][20191210211845809.png]  
![在这里插入图片描述][20191210211902976.png]  
![在这里插入图片描述][20191210211911199.png]  
中间部分图省略，可以看到 `main`中打印的东西和线程`thread1`交替执行，也就是并行执行。

而使用 `join()`方法之后，线程会变成串行，如下图所示；  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 5]  
join构造方法

void join()  
    void join(long millis, int nanos) millis代表秒，nanos 纳秒
    void  join(long millis) millis 秒

join() 相等于 join(0) 表示不等待当前main线程  
join()必须在start()之后执行

表示等待当前线程多少毫秒，纳秒。

设置 `thread1.join(1)` 等待1毫秒  
如果超出等待时间，main 线程会继续执行下去，结果如下图；

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 6]  
![在这里插入图片描述][20191210213025552.png]  
如果启动多个线程，thread1和thread2会交替执行结束，main线程才会执行。

最后可以通过源码看到 `join()`内部实现是用`wait()`方法进行等待的，所以`join()`具有`释放锁`的特点。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 7]

### 打断线程 ###

打断线程有三种方法

*  1 设置标志，使线程退出循环
 *  2 使用interrupt() 方法
 *  3 使用stop()方法 但不推荐使用，已废弃。

#### 方法一 ####

适用于一些循环执行一些任务 ，关闭的时候设置标识退出线程。

public static class Worker1 extends Thread { 
    
            //执行标志
            public boolean falg = true;
    
            @Override
            public void run() { 
    
                while (falg) { 
                    System.out.println(" 执行逻辑1 ");
                }
            }
    
            public void shutdown() { 
                System.out.println("falg");
                falg = false;
                System.out.println("falg");
            }
        }

启动关闭

Worker1 worker1 = new Worker1();
            worker1.start();
            try { 
                Thread.sleep(2_000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
            worker1.shutdown();

可以看到执行逻辑1后，再设置标识为fasle后程序线程退出,虚拟机退出。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 8]

#### 方法二 ####

interrupt方法终止线程，使用interrupt 有两种

*  如果执行代码中有sleep方法，会抛出异常。

public static class Worker2 extends Thread { 
    
    
            @Override
            public void run() { 
    
                while (true) { 
                    System.out.println(" 执行逻辑2 ");
    
                     /* try { Thread.sleep(1); } catch (InterruptedException e) { //e.printStackTrace(); System.out.println("停止线程"); break; // 或者return; }*/
    
    
                    if (this.isInterrupted()) { 
                        System.out.println("停止线程");//可以执行不是循环的业务
                        break;
                        //return;
                    }
    
    
                    // break 时候可以继续执行一些逻辑， return 直接退出
                    // ----------
    
                }
            }

*  使用while（! isInterrupted（））\{……\}来判断线程是否被中断。

public static class Worker22 extends Thread { 
    
    
            @Override
            public void run() { 
                System.out.println(" 开始执行 ");
                while (!this.isInterrupted()) { 
                    System.out.println(" 执行逻辑2 ");
                }
            }
    
        }

启动停止

Worker22 worker22 = new Worker22();
            worker22.start();
            try { 
                Thread.sleep(1_000);
            } catch (InterruptedException e) { 
                e.printStackTrace();
            }
    
            worker22.interrupt();

#### 方法三 ####

使用stop方法终止线程 使用stop方法可以强行终止正在运行或挂起的线程。我们可以使用如下的代码来终止线程： thread.stop();  
此方法已经被禁止使用，就不演示了。

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20191208151636246.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/20191208143521987.jpg?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70
[20191208155749689.png]: https://img-blog.csdnimg.cn/20191208155749689.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20191208160155495.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20191208160445211.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70
[2019120816051929.png]: https://img-blog.csdnimg.cn/2019120816051929.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/2019120816084133.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70
[20191208170213116.png]: https://img-blog.csdnimg.cn/20191208170213116.png
[20191208174446499.png]: https://img-blog.csdnimg.cn/20191208174446499.png
[20191208180944256.png]: https://img-blog.csdnimg.cn/20191208180944256.png
[20191210211845809.png]: https://img-blog.csdnimg.cn/20191210211845809.png
[20191210211902976.png]: https://img-blog.csdnimg.cn/20191210211902976.png
[20191210211911199.png]: https://img-blog.csdnimg.cn/20191210211911199.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 5]: https://img-blog.csdnimg.cn/20191210212055164.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 6]: https://img-blog.csdnimg.cn/20191210212647538.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70
[20191210213025552.png]: https://img-blog.csdnimg.cn/20191210213025552.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 7]: https://img-blog.csdnimg.cn/20191210213340725.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw_size_16_color_FFFFFF_t_70 8]: https://img-blog.csdnimg.cn/20200609224152294.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl8zODM2MTM0Nw==,size_16,color_FFFFFF,t_70