Java线程、多线程简述

青旅半醒 2024-03-26 16:19 135阅读 0赞

#### 目录 ####

*  一、如何创建一个线程
 *   *  1、Thread类
     *  2、Runnable接口
     *  3、Callable接口
     *  4、Thread、Runnable和Callable比较
     *  5、线程run方法和start方法区别
     *  6、静态代理
 *  二、线程有哪些状态
 *   *  1、线程生命周期
     *  2、线程状态
 *  三、线程常用方法
 *   *  1、常用方法说明
     *  2、线程停止
     *  3、线程睡眠-sleep
     *  4、线程礼让-yield
     *  5、线程插队-join
     *  6、线程优先级-priority（了解）
     *  7、守护线程-daemon（了解）
 *  四、线程锁
 *   *  1、synchronized
     *  2、Lock
     *  3、死锁
     *  4、线程通信-管程法
     *  5、线程池
     *  6、ThreadLocal 使用

**首先可以了解下什么是线程**

[什么是进程、线程、线程安全？以及之间的关联关系][Link 1]

## 一、如何创建一个线程 ##

有三种方式：继承Thread类、实现runnable接口、实现Callable接口

### 1、Thread类 ###

继承Thread类，并重写run方法，然后调用这个线程类的start方法，即可实现一个线程的调用

public class Test extends Thread{
        
        @Override
        public void run() {
        
            System.out.println("线程逻辑");
        }
        public static void main(String[] args) {
        
            Test test = new Test();
            test.start();
        }
    }

### 2、Runnable接口 ###

实现Runnable方法，并重写run方法，然后实例化这个类，并new Thread，再把test传进去，调用start方法，即可实现一个线程的调用

public class Test implements Runnable{
        
        @Override
        public void run() {
        
            System.out.println("执行了run方法");
        }
        public static void main(String[] args) {
        
            Test test = new Test();
            // Thread thread = new Thread(test); 代理
            // thread.start();
            new Thread(test).start();
        }
    }

### 3、Callable接口 ###

实现Callable方法，并重写call方法，然后实例化这个类，开启一个线程池来调用这个类，并打印返回值。

public class CallTest implements Callable<String> {
        
    
        @Override
        public String call() throws Exception {
        
            return "调用call方法成功";
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            CallTest test1 = new CallTest();
            CallTest test2 = new CallTest();
            CallTest test3 = new CallTest();
            // 开启一个固定线程池，最大线程数为3
            ExecutorService executor = Executors.newFixedThreadPool(3);
            // 通过线程池执行线程
            Future<String> future1 = executor.submit(test1);
            Future<String> future2 = executor.submit(test2);
            Future<String> future3 = executor.submit(test3);
            // 备注：调用get方法会使主线程等待，所有get执行完了才能执行后面逻辑
            System.out.println(future1.get());
            System.out.println(future2.get());
            System.out.println(future3.get());
            // 终止线程池
            executor.shutdown();
        }
    }

### 4、Thread、Runnable和Callable比较 ###

*  `Thread` 不建议使用，避免OOP单继承局限
 *  `Runnable` 推荐使用，避免OOP单继承局限，而且方便同一个对象被多个线程调用

// 多份代理
    	Test test = new Test();
        new Thread(test,"线程1").start();
        new Thread(test,"线程2").start();
        new Thread(test,"线程3").start();
        // 一份资源
        new Test().start();

*  `Callable`实现方式和Runnable类似，因为两者都是为其实例所在的类设计的，可能由另一个线程执行。`区别在于Callable有返回值，并能返回结果抛出一个已检查异常`。

### 5、线程run方法和start方法区别 ###

线程里面的run方法只是一个普通的方法，如果直接调用run方法，启动了main方法。就只有一个主线程，所以会按顺序先执行test.run方法再执行后面的逻辑。  
![在这里插入图片描述][1a938874baa142ffb64ed5eb6bd20f21.png]  
要调用start方法才能成功启动test这个线程，这时候test这个线程和main这个主线程就构成了多线程，多线程谁先抢到了cpu资源，谁就先执行。因为start方法会去启动这个线程并调用run方法。  
![在这里插入图片描述][0e4a251c682f4682920991374347cc7f.png]

### 6、静态代理 ###

/*
     静态代理模式（例：结婚的时候需要找一个婚庆公司布置现场,婚庆公司是代理类,我结婚是真实类）
     真实对象和代理对象都要实现同一个接口
     代理对象要代理真实对象
     优点：代理对象可以做真实对象做不了的事，真实对象只需要专注做自己的事
     */
    public class CallTest{
        
        public static void main(String[] args) {
        
            MyProxy proxy = new MyProxy(new My());
            proxy.myMethod();
        }
    }
    
    // 父方法
    interface MyBase{
        
        public void myMethod();
    }
    // 真实角色
    class My implements MyBase{
        
    
        @Override
        public void myMethod() {
        
            System.out.println("我结婚了");
        }
    }
    // 代理类
    class MyProxy implements MyBase{
        
    
        private MyBase myBase;
        public MyProxy(MyBase base){
        
            this.myBase = base;
        }
        
        @Override
        public void myMethod() {
        
            System.out.println("前置，婚庆公司布置现场");
            this.myBase.myMethod();
            System.out.println("后置，婚庆公司接收尾款");
        }
    }

// 打印：
    前置，婚庆公司布置现场
    我结婚了
    后置，婚庆公司接收尾款

总结：

// 对比如下，是不是觉得很相似
    
    new MyProxy(new My()).myMethod();
    new Thread(test).start(); // 第二步，实现Runnable方法里面的代码
    
    Thread类就是一个代理类，和test都实现了Runnable方法。并且都执行了的run方法。

## 二、线程有哪些状态 ##

### 1、线程生命周期 ###

线程的生命周期包含5个阶段：新建、就绪、运行、阻塞、死亡  
![在这里插入图片描述][ddfc01ddd2fe41eb8de722ef23b3097a.png]

### 2、线程状态 ###

*  `NEW` (新建)尚未启动的线程处于此状态。
 *  `RUNNABLE` (运行)在Java虚拟机中执行的线程处于此状态。
 *  `BLOCKED` (阻塞)被阻塞等待监视器锁定的线程处于此状态。
 *  `WAITING` (等待)正在等待另一个线程执行特定动作的线程处于此状态。
 *  `TIMED_WAITING` (时间等待)正在等待另一个线程执行动作达到指定等待时间的线程处于此状态。
 *  `TERMINATED` (终止)已退出的线程处于此状态。

public class CallTest{
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread thread = new Thread(()->{
        
                try {
        
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            });
            // 新建线程后，打印状态
            System.out.println("新建线程后，线程状态："+thread.getState());
            // 启动线程后，打印状态
            thread.start();
            System.out.println("启动线程后，线程状态："+thread.getState());
            // 睡眠0.5秒，打印状态
            Thread.sleep(500);
            System.out.println("睡眠0.5秒，线程状态："+thread.getState());
            // 睡眠1秒，打印状态
            Thread.sleep(1000);
            System.out.println("睡眠1秒后，线程状态："+thread.getState());
            // 线程死亡后不能再次启动，否则会报错
            thread.start();
        }
    }

打印：

新建线程后，线程状态：NEW
    启动线程后，线程状态：RUNNABLE
    睡眠0.5秒，线程状态：TIMED_WAITING
    睡眠1秒后，线程状态：TERMINATED
    Exception in thread "main" java.lang.IllegalThreadStateException
    	at java.lang.Thread.start(Thread.java:708)
    	at com.swp.entity.CallTest.main(CallTest.java:36)

## 三、线程常用方法 ##

### 1、常用方法说明 ###

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

### 2、线程停止 ###

不推荐使用JDK提供的 stop()、destroy（)方法。【已废弃】  
推荐线程自己停止下来，建议使用一个标志位进行终止变量当flag=false，则终止线程运行。

public class Test implements Runnable{
        
        // 1、线程汇总定义线程体使用的标识
        private boolean flag = true;
        @Override
        public void run() {
        
            // 2、线程体使用该标识
            while (flag){
        
                System.out.println("执行了run方法");
            }
        }
    
        // 3、对外提供方法改变标识
        public void stop(){
        
            this.flag = false;
        }
    
        public static void main(String[] args) {
        
            Test test = new Test();
            new Thread(test).start();
            // 执行某些逻辑。。。,调用stop方法停止线程
            test.stop();
        }
    }

### 3、线程睡眠-sleep ###

*（可用于测试并发，线程等待等场景）*  
`sleep` 指定当前线程阻塞的毫秒数；  
sleep存在异常InterruptedException;  
sleep时间达到后线程进入就绪状态;  
sleep可以模拟网络延时,倒计时等。  
每一个对象都有一个锁，sleep不会释放锁；

public class Test implements Runnable{
        
        @Override
        public void run() {
        
            try {
        
                // 睡眠1秒
                Thread.sleep(1000);
                System.out.println(Thread.currentThread().getName() + "执行了run方法," + LocalDateTime.now());
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
        }
        public static void main(String[] args) {
        
            Test test = new Test();
            System.out.println(LocalDateTime.now());
            new Thread(test,"线程1").start();
            new Thread(test,"线程2").start();
        }
    }

打印结果：
    2023-03-03T00:06:16.253
    线程1执行了run方法,2023-03-03T00:06:17.261
    线程2执行了run方法,2023-03-03T00:06:17.261

### 4、线程礼让-yield ###

`yield`礼让线程，不会阻塞，将线程从运行状态转为就绪状态让cpu重新调度  
礼让不一定成功，看谁先被CPU调用  
一般可以用于测试和调试并发产生的bug

public class Test implements Runnable{
        
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName() + "进入了run方法");
            Thread.yield();
            System.out.println(Thread.currentThread().getName() + "结束了run方法");
        }
        public static void main(String[] args) {
        
            Test test = new Test();
            new Thread(test,"线程1").start();
            new Thread(test,"线程2").start();
        }
    }
    // 执行过程有可能是A先礼让然后竞争，也有可能是B先礼让然后竞争

打印结果1：
    线程1进入了run方法
    线程2进入了run方法
    线程1结束了run方法
    线程2结束了run方法
    
    打印结果2：
    线程2进入了run方法
    线程1进入了run方法
    线程2结束了run方法
    线程1结束了run方法
    
    也有可能是三四种结果。。。这里不一一列举

### 5、线程插队-join ###

`join`加入，可以理解为线程插队，`会使线程阻塞`

// 当主线程执行三次后，子线程插队进来，必须等子线程执行完了才能执行主线程
    public class Test implements Runnable{
        
        @Override
        public void run() {
        
            for(int i=1;i<5;i++){
        
                System.out.println("run方法跑了"+i+"次");
            }
        }
        
        public static void main(String[] args) throws InterruptedException {
        
            Thread thread = new Thread(new Test(),"线程1");
            thread.start();
    		// 执行主线程
            for(int i=0;i<6;i++){
        
                System.out.println("主线程");
                if(i==2){
        
                // 子线程插队
                    thread.join();
                }
            }
        }
    }

打印结果：
    
    主线程
    主线程
    主线程
    run方法跑了1次
    run方法跑了2次
    run方法跑了3次
    run方法跑了4次
    主线程
    主线程
    主线程

### 6、线程优先级-priority（了解） ###

优先级低只是意味着获得调度的概率低，并不是优先级低就不会被调用了，优先级越高也只是被调用概率越高，这都是看CPU的调度

public class CallTest implements Runnable{
        
        public static void main(String[] args) throws InterruptedException {
        
            CallTest run = new CallTest();
            Thread t1 = new Thread(run,"线程1");
            Thread t2 = new Thread(run,"线程2");
            Thread t3 = new Thread(run,"线程3");
            Thread t4 = new Thread(run,"线程4");
    
            t1.setPriority(1);// 优先级最低
            t2.setPriority(3);
            t3.setPriority(7);
            t4.setPriority(Thread.MAX_PRIORITY);// 优先级最大
    
            t2.start();
            t3.start();
            t4.start();
            t1.start();
    
        }
    
        @Override
        public void run() {
        
            System.out.println(Thread.currentThread().getName()+"-->优先级："+Thread.currentThread().getPriority());
        }
    }

打印：

线程2-->优先级：3
    线程4-->优先级：10
    线程3-->优先级：7
    线程1-->优先级：1

### 7、守护线程-daemon（了解） ###

线程分为`用户线程`和`守护线程`  
虚拟机必须确保用户线程执行完毕(如：main)  
虚拟机不用等待守护线程执行完(如：gc)  
毕如，后台记录操作日志，监控内存，垃圾回收等待…

Thread a= new Thread();
        a.setDaemon(true); // 设置为守护线程，默认为false

## 四、线程锁 ##

线程同步以及并发引起的线程安全问题，主要用synchronized 和 lock锁来实现

### 1、synchronized ###

**模拟并发场景一（synchronized关键字）：**

public class Test implements Runnable{
        
        private int a = 5;
        @Override
        public void run() {
        
            while (a > 0){
        
                try {
        
                    Thread.sleep(10);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName() +"拿到了"+ a--);
            }
        }
        public static void main(String[] args) throws InterruptedException {
        
            Test test = new Test();
            new Thread(test,"线程1").start();
            new Thread(test,"线程2").start();
            new Thread(test,"线程3").start();
        }
    }

打印结果：

线程3拿到了4
    线程1拿到了5
    线程2拿到了3
    线程2拿到了2
    线程1拿到了2
    线程3拿到了2
    线程3拿到了1
    线程1拿到了1
    线程2拿到了1

**加上synchronized关键字**

public class Test implements Runnable{
        
        private int a = 5;
        @Override
        public synchronized void run() {
        
            while (a > 0){
        
                try {
        
                    Thread.sleep(10);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
                System.out.println(Thread.currentThread().getName() +"拿到了"+ a--);
            }
        }
        public static void main(String[] args) throws InterruptedException {
        
            Test test = new Test();
            new Thread(test,"线程1").start();
            new Thread(test,"线程2").start();
            new Thread(test,"线程3").start();
        }
    }

打印结果：

线程1拿到了5
    线程1拿到了4
    线程1拿到了3
    线程1拿到了2
    线程1拿到了1

**模拟并发场景二（synchronized块）：**

public class Test implements Runnable{
        
            private Integer a = 5;
            @Override
            public void run() {
        
                synchronized (a){
        
                    while (a > 0){
        
                        try {
        
                            Thread.sleep(10);
                        } catch (InterruptedException e) {
        
                            throw new RuntimeException(e);
                        }
                        System.out.println(Thread.currentThread().getName() +"拿到了"+ a--);
                    }
                }
            }
            public static void main(String[] args) {
        
                Test test = new Test();
                new Thread(test,"线程1").start();
                new Thread(test,"线程2").start();
                new Thread(test,"线程3").start();
            }
        }

打印结果：

线程1拿到了5
    线程1拿到了4
    线程1拿到了3
    线程1拿到了2
    线程1拿到了1

> **总结**：synchronized关键字和synchronized块作用相同，都是加同步锁，让线程排队，一个一个进来。但是使用方式不一样。  
> synchronized关键字可以加在整个方法上，而synchronized块是用括号包含一段代码（如逻辑A是查询，逻辑B是修改）。而synchronized块小括号里面的参数就是需要保障数据安全的对象。

### 2、Lock ###

这里使用Lock的实现类ReentrantLock（可重入锁）来实现，语法如下：

class A{
        
    	private final ReentrantLock lock = new ReenTrantLock(); 
    	public void m(){
        
    		try{
        
    			lock.lock();
    			//保证线程安全的代码；
    		finally{
        
    			// 释放锁
    			lock.unlock(); // 如果同步代码有异常,要将unlock()写入finally语句块
    		}
    	}
    }

### 3、死锁 ###

死锁是指两个或两个以上的进程在执行过程中，由于竞争资源或者由于彼此通信而造成的一种阻塞的现象，若无外力作用，它们都将无限等待。  
**演示：**  
有两个线程（小明、小花）都想写作，因此他们都必须得到笔和纸，当小明进去后拿到了笔会睡眠一秒，这时候小花也拿到了纸也会睡眠一秒。一秒过后小明渴望拿到纸，但是纸还在小花手上；而小花渴望拿到笔，但是笔还在小明手上，这时就会相互阻塞，称为死锁

public class Test {
        
        public static void main(String[] args) {
        
            Thread a = new Thread(new Writing(1), "小明");
            Thread b = new Thread(new Writing(2), "小花");
            a.start();
            b.start();
        }
    }
    // 笔
    class Pen{
        
    }
    // 纸
    class Paper{
        
    }
    // 写作
    class Writing implements Runnable{
        
    	// 加上static让这个类下面的笔和纸都唯一
        private static Pen pen = new Pen();
        private static Paper paper = new Paper();
    
        private int type;
        public Writing(int type) {
        
            this.type = type;
        }
    
        @Override
        public void run() {
        
            try {
        
                open();
            } catch (InterruptedException e) {
        
                throw new RuntimeException(e);
            }
        }
    	// 小明走if，小花走else，当小明和小花分别拿到了笔和纸时，睡眠一秒（模拟线程同步），这时小明已经拿到了笔想要得到纸，
    	// 而小花拿到了纸想得到笔。但是由于纸和笔都只有一份，并且都在他们各自手上，因此都拿不到，就会一直阻塞，就造成了死锁。
        private void open() throws InterruptedException {
        
            if(type == 1){
        
                synchronized (pen){
        
                    System.out.println(Thread.currentThread().getName()+"拿到了笔");
                    Thread.sleep(1000);
                    synchronized (paper){
        
                        System.out.println(Thread.currentThread().getName()+"拿到了纸");
                    }
                }
            }else {
        
                synchronized (paper){
        
                    System.out.println(Thread.currentThread().getName()+"拿到了纸");
                    Thread.sleep(1000);
                    synchronized (pen){
        
                        System.out.println(Thread.currentThread().getName()+"拿到了笔");
                    }
                }
            }
        }
    }

打印：

小明拿到了笔
    小花拿到了纸 // 后面就会进入死锁

**改进：**  
当把open()方法改成如下时，即可避免死锁。  
因为把加锁的代码拿了出来，所以当同时启动小明和小花的时候，执行顺序是：首先打印a c，经过一秒后，a释放 b会进入就绪，再过两秒c释放，b d 进入就绪并运行，打印 b d 然后释放 b d

private void open() throws InterruptedException {
        
            System.out.println(new Date());
            if(type == 1){
        
            	// a
                synchronized (pen){
        
                    System.out.println(Thread.currentThread().getName()+"拿到了笔");
                    Thread.sleep(1000);
                }
                // b
                System.out.println(Thread.currentThread().getName()+new Date());
                synchronized (paper){
        
                    System.out.println(Thread.currentThread().getName()+"拿到了纸");
                }
            }else {
        
            	// c
                synchronized (paper){
        
                    System.out.println(Thread.currentThread().getName()+"拿到了纸");
                    Thread.sleep(3000);
                }
                // d
                synchronized (pen){
        
                    System.out.println(Thread.currentThread().getName()+"拿到了笔");
                }
                System.out.println(Thread.currentThread().getName()+new Date());
            }
        }

打印：

Sat Mar 04 14:27:07 CST 2023
    Sat Mar 04 14:27:07 CST 2023  // 进来的时间
    小明拿到了笔
    小花拿到了纸
    小明Sat Mar 04 14:27:08 CST 2023 // 一秒过后，a释放b等待
    小花拿到了笔
    小明拿到了纸
    小花Sat Mar 04 14:27:10 CST 2023 // 两秒过后 c释放，b运行释放，d运行释放

> *注：为什么 a b 没有同时运行，因为a加synchronized关键字（同步锁),因此必须a执行完了才会执行b。c d也一样*

**总结：任意一方先释放锁，就能避免死锁**

### 4、线程通信-管程法 ###

首先了解如下方法，  
注意：均是Object类的方法，`都只能在同步方法或者同步代码块中使用`,否则会抛出异常1llegalMonitorStateException  
![在这里插入图片描述][cb39312155054a4a98183e170ff7769d.png]

用生产者、消费者来模拟不同线程通信

//测试：生产者消费者模型-->利用缓冲区解决：管程法
    //生产者，消费者，产品，缓冲区
    public class Test {
        
        public static void main(String[] args) {
        
            SynContainer container = new SynContainer();
    
            new Productor(container).start();
            new Consumer(container).start();
        }
    }
    
    //生产者
    class Productor extends Thread{
        
        SynContainer container;
        public Productor(SynContainer container){
        
            this.container=container;
        }
        // 生产
        @Override
        public void run() {
        
            for (int i = 1; i < 6; i++) {
        
                System.out.println("生产了第"+ i +"只鸡");
                container.push(new Chicken(i));
            }
        }
    }
    // 消费者
    class Consumer extends Thread{
        
        SynContainer container;
        public Consumer(SynContainer container){
        
            this.container=container;
        }
    
        @Override
        public void run() {
        
            for (int i = 0; i < 5; i++) {
        
                System.out.println("消费了第-->"+container.pop().id+"只鸡");
            }
        }
    }
    
    // 产品（鸡）
    class Chicken{
        
        int id;//产品编号
        public Chicken(int id) {
        
            this.id = id;
        }
    }
    
    //缓冲区
    class SynContainer {
        
        // 需要一个容器大小
        Chicken[] chickens = new Chicken[10];
        //容器计数器
        int count = 0;
    
        //生产者放入产品
        public synchronized void push(Chicken chicken) {
        
            //如果容器满了，就需要等待消费消费
            if (count == chickens.length) {
        
                //通知消费者消费，生产等待
                try {
        
                    this.wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
            // 如果没有满，我们就需要丢入产品
            chickens[count] = chicken;
            count++;
            //可以通知消费者消费
            this.notifyAll();
        }
    
        //消费者消费产品
        public synchronized Chicken pop() {
        
    
            //判断能否消费
            if(count==0){
        
                //等待生产者生产，消费者等待
                try {
        
                    this.wait();
                } catch (InterruptedException e) {
        
                    e.printStackTrace();
                }
            }
            // 如果可以消费I
            count--;
            Chicken chicken = chickens[count];
    
            //吃完了，通知生产者生产
            this.notifyAll();
            return chicken;
        }
    }

打印：

生产了第1只鸡
    生产了第2只鸡
    生产了第3只鸡
    生产了第4只鸡
    消费了第-->4只鸡
    生产了第5只鸡
    消费了第-->5只鸡
    消费了第-->3只鸡
    消费了第-->2只鸡
    消费了第-->1只鸡

### 5、线程池 ###

线程池的创建可以参考这篇文章：**[Java之线程池][Java]**

### 6、ThreadLocal 使用 ###

[深入理解Java中的ThreadLocal][Java_ThreadLocal]

[Link 1]: https://blog.csdn.net/weixin_44183847/article/details/122702828?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522167792405516800182177165%2522%252C%2522scm%2522%253A%252220140713.130102334.pc%255Fblog.%2522%257D&request_id=167792405516800182177165&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~blog~first_rank_ecpm_v1~rank_v31_ecpm-1-122702828-null-null.blog_rank_default&utm_term=%E7%BA%BF%E7%A8%8B&spm=1018.2226.3001.4450
[1a938874baa142ffb64ed5eb6bd20f21.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/5c97a8d5908f4132ae840d11cc2180dd.png
[0e4a251c682f4682920991374347cc7f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/235f50b64f1046e9be10afb0517995f3.png
[ddfc01ddd2fe41eb8de722ef23b3097a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/535ebc5b114d4376a6467ceff068d92e.png
[ca47b42693804f98999b6dab8704c0fd.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/00d573b5d1784b70bdf453a6f2f6f60e.png
[cb39312155054a4a98183e170ff7769d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/26/f1cb44313ce84d0a95f66fc666f3e7b4.png
[Java]: https://blog.csdn.net/weixin_44183847/article/details/118941526?csdn_share_tail=%7B%22type%22:%22blog%22,%22rType%22:%22article%22,%22rId%22:%22118941526%22,%22source%22:%22weixin_44183847%22%7D
[Java_ThreadLocal]: https://blog.csdn.net/weixin_44183847/article/details/134193515?csdn_share_tail=%7B%22type%22:%22blog%22,%22rType%22:%22article%22,%22rId%22:%22134193515%22,%22source%22:%22weixin_44183847%22%7D