Java进阶（再论线程）——线程的4种创建方式 & 线程的生命周期 & 线程的3大特性 & 集合中的线程安全问题

傷城~ 2024-02-19 09:25 6阅读 0赞

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

## 前言 ##

多线程作为编程语言中的难点，虽然初级程序员可能很少遇到线程相关的开发任务，但是作为程序员，持续学习和保持对编程的热爱，要求我们对于线程也需要有一定的认识。

本篇博客介绍Java中创建线程的4种方式，并进行了简单的对比；介绍了线程的生命周期，几个关键方法的作用；然后阐述了线程的三大特性，最后结合Java集合框架分析了线程安全的问题。

其他关于Java线程的文章如下：

*  [Java进阶（5）——创建多线程的方法extends Thread和implements Runnable的对比 & 线程池及常用的线程池][Java_5_extends Thread_implements Runnable_ _]
 *  [Java进阶（6）——抢购问题中的数据不安全（非原子性问题）& Java中的synchronize和ReentrantLock锁使用 & 死锁及其产生的条件][Java_6_ Java_synchronize_ReentrantLock_ _]

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

*  前言
 *  引出
 *  一、创建多线程的方式
 *   *  1、继承Thread类
     *   *  当前线程：Thread.currentThread()
     *  2、实现Runable接口
     *  3、实现Callable接口
     *  4、线程池
 *  二、线程的生命周期
 *   *  join()：运行结束再下一个
     *  yield()：暂时让出cpu的使用权
     *  deamon()：守护线程，最后结束
     *  sleep()：如果有锁，不会让出
 *  三、线程的三大特性
 *   *  原子性：AtomicInteger
     *   *  CAS
     *  可见性：加volatile关键字
     *  有序性：引用有了，对象还没
 *  四、集合中的线程安全问题
 *   *  1、List集合的问题
     *   *  用vector解决
         *  用Collections.synchronizedList
     *  2、表格总结
     *  3、关于hash算法
 *  总结

## 引出 ##

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

1.线程创建的方式，继承Thread类，实现Runable接口，实现Callable接口，采用线程池；  
2.线程生命周期： join()：运行结束再下一个， yield()：暂时让出cpu的使用权，deamon()：守护线程，最后结束，sleep()：如果有锁，不会让出；  
3.线程3大特性，原子性，可见性，有序性；  
4.list集合中线程安全问题，hash算法问题；

## 一、创建多线程的方式 ##

### 1、继承Thread类 ###

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

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

调用的流程：

*  调用start()
 *  线程处于准备状态，一旦cup有闲的时间片，
 *  让线程调用run（）方法

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

package com.tianju.threadLearn;
    
    public class ThreadA extends Thread{
        
    
        @Override
        public void run(){
        
            System.out.println("我是线程A："+this.getName());
        }
    
        public static void main(String[] args) {
        
            ThreadA threadA = new ThreadA();
            threadA.setName("线程A");
    
            threadA.start(); // 我准备好了
    
            String name = Thread.currentThread().getName();
            System.out.println(name);
    
            // 获得当前线程的路径
            String path = Thread.currentThread().getContextClassLoader().getResource("").getPath();
            System.out.println(path);
    
        }
    }

#### 当前线程：Thread.currentThread() ####

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

### 2、实现Runable接口 ###

和继承Thread相比，这个用的更多，因为Java是单继承的，只能继承一个，而可以实现多个接口，所以更加灵活

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

package com.tianju.threadLearn;
    
    /**
     * 这个常用，因为java是单继承，如果继承了extends Thread；
     * 就不能继续继承了；
     */
    public class ThreadB implements Runnable{
        
    
        private String name;
        public ThreadB(String name){
        
            this.name = name;
        }
    
        @Override
        public void run() {
        
            for(int i =0;i<10;i++){
        
                System.out.println("当前线程："+this.name);
                try {
        
                    Thread.sleep(200);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    
        public static void main(String[] args) {
        
            new Thread(new ThreadB("B")).start();
        }
    }

### 3、实现Callable接口 ###

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

package com.tianju.threadLearn;
    
    
    import java.util.concurrent.Callable;
    import java.util.concurrent.ExecutionException;
    import java.util.concurrent.FutureTask;
    
    /**
     * Callable，可以有返回值
     */
    public class ThreadC implements Callable<Long> {
        
    
    
    
        @Override
        public Long call() throws Exception {
        
            long sum = 0;
            for (int i = 0; i < 500000; i++) {
        
                sum+=i;
            }
            return sum;
        }
    
        public static void main(String[] args) throws ExecutionException, InterruptedException {
        
            FutureTask<Long> threadC = new FutureTask<Long>(new ThreadC());
            Thread thread = new Thread(threadC);
            thread.start();
            Long aLong = threadC.get();
            System.out.println(aLong);
        }
    }

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

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

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

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

### 4、线程池 ###

池化技术pool【常量池、数据连接池、线程池】

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

package com.tianju.threadLearn;
    
    
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    public class PoolDemo1 {
        
        public static void main(String[] args) {
        
            System.out.println("===============缓存线程池================");
            ExecutorService executorService = Executors.newCachedThreadPool();
            for (int i=0;i<10;i++) {
        
                executorService.execute(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println(Thread.currentThread());
                    }
                });
            }
            System.out.println("===============固定线程池================");
            ExecutorService executorService2 = Executors.newFixedThreadPool(1);
            for (int i=0;i<10;i++) {
        
                executorService2.execute(new Runnable() {
        
                    @Override
                    public void run() {
        
                        System.out.println(Thread.currentThread());
                    }
                });
            }
        }
    }

## 二、线程的生命周期 ##

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

### join()：运行结束再下一个 ###

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

package com.tianju.threadLearn;
    
    public class ThreadA1 extends Thread{
        
    
        static int c = 0;
    
        @Override
        public void run(){
        
            for (int i = 0; i < 20; i++) {
        
    
                try {
        
                    System.out.println(this.getName()+": "+i);
                    sleep(300);
                    c++;
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            ThreadA1 a = new ThreadA1();
            a.setName("A");
    
            ThreadA1 b = new ThreadA1();
            b.setName("B");
            a.start();
            a.join(); // A运行结束，B才能开始运行
    
            b.start();
            b.join(); // 控制执行顺序
    
            System.out.println(Thread.currentThread().getName());
            System.out.println("c的结果为: "+c);
    
        }
    }

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

### yield()：暂时让出cpu的使用权 ###

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

package com.tianju.threadLearn;
    
    /**
     * yield，让出cpu的使用权
     */
    public class ThreadA2 extends Thread{
        
    
        @Override
        public void run(){
        
            for (int i = 0; i < 20; i++) {
        
    
                try {
        
                    if (i%2==0){
        
                        // 让出cpu的使用权，避免一个线程一直占有cpu，防止独占cpu
                        // 重新竞争
                        yield();
                    }
                    System.out.println(this.getName()+": "+i);
                    sleep(300);
    
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            ThreadA2 a = new ThreadA2();
            a.setName("A");
    
            ThreadA2 b = new ThreadA2();
            b.setName("B");
            a.start();
    
            b.start();
    
            System.out.println(Thread.currentThread().getName());
    
        }
    }

### deamon()：守护线程，最后结束 ###

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

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

package com.tianju.threadLearn;
    
    /**
     * 守护线程
     * 用户线程
     *
     */
    public class ThreadA3 extends Thread{
        
    
        @Override
        public void run(){
        
    
            while (true){
        
                System.out.println("我是守护线程.......");
                try {
        
                    sleep(100);
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
    
            ThreadA3 a = new ThreadA3();
            a.setName("A");
            a.setDaemon(true); // 守护线程，用户线程main结束后，他就结束了
            a.start();
    
            for (int i =0;i<10;i++){
        
                System.out.println(Thread.currentThread()+":"+i);
                Thread.sleep(200);
            }
    
        }
    }

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

### sleep()：如果有锁，不会让出 ###

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

package com.tianju.threadLearn;
    
    public class ThreadSleep extends Thread{
        
    
    
    
        @Override
        public void run(){
        
    
            for (int i=0;i<10;i++){
        
                System.out.println("我是线程A："+this.getName());
    
                try {
        
                    sleep(200); // 不会让出锁
                } catch (InterruptedException e) {
        
                    throw new RuntimeException(e);
                }
            }
    
        }
    
        public static void main(String[] args) {
        
            ThreadSleep threadA = new ThreadSleep();
            threadA.setName("线程A");
    
            threadA.start(); // 我准备好了
    
            String name = Thread.currentThread().getName();
            System.out.println(name);
    
        }
    }

## 三、线程的三大特性 ##

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

### 原子性：AtomicInteger ###

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

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

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

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

package com.tianju.tx;
    
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * 解决原子性：AtomicInteger
     */
    public class AtomicDemo1 {
        
        static AtomicInteger x= new AtomicInteger();
        static class A extends Thread{
        
            @Override
            public void run() {
        
    
                for (int i = 0; i < 20; i++) {
        
                    x.incrementAndGet();
                    System.out.println(getName()+ "--x:"+x);
                    try {
        
                        sleep(200);
                    } catch (InterruptedException e) {
        
                        throw new RuntimeException(e);
                    }
    
                }
            }
        }
    
        public static void main(String[] args) {
        
            new A().start();
            new A().start();
            new A().start();
        }
    }

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

#### CAS ####

> CAS(Compare And Swap)

*  从主存拷贝到工作内存(线程)
 *  修改，和主存比较，如果如果和取时结果一致，刷新到主存中。

> ABA问题:
> 
> 如果红色线程拿到了主存中的3，进行加1,；
> 
> 蓝色线程也拿到了主存中的3，进行了加1，然后又减1；
> 
> 红色线程一直问主存里面是不是3，然后发现还是3，就把4写到主存里面；
> 
> 但是此时的3已经被蓝色线程动过了；
> 
> 解决方案是，加一个版本号，每次被操作，就让版本号加1

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

### 可见性：加volatile关键字 ###

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

package com.tianju.view;
    
    /**
     * 线程之间不可见
     * volatile 用于解决可见性
     */
    public class VisibleDemo2 {
        
        volatile static boolean f = true; // 处理可见性，解决不了原子性
        static class A extends Thread{
        
    
            @Override
            public void run() {
        
                while (f){
        
    
                }
                System.out.println("A的f为："+f);
            }
        }
        static class B extends Thread{
        
            @Override
            public void run() {
        
                f=false;
                System.out.println("B设置f为："+f);
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            new A().start();
            Thread.sleep(300);
            new B().start();
        }
    }

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

### 有序性：引用有了，对象还没 ###

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

> 假设： 编译器修改顺序 1 , 3, 2
> 
> 线程A执行到对象初始化阶段，还没有初始化；
> 
> 线程B先获得的对象的引用，然后调用对象，
> 
> 但是对象还没有初始化，因此会报错，对象初始化错误

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

## 四、集合中的线程安全问题 ##

### 1、List集合的问题 ###

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

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

package com.tianju.collection;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class ListDemo {
        
        static List<Integer> list = new ArrayList<>();
    
        // 有序性+原子性保证
        volatile static AtomicInteger index =new AtomicInteger(0);
        static class A extends Thread{
        
            @Override
            public void run() {
        
                for (int i = 0; i < 20; i++) {
        
                    list.add(index.incrementAndGet());
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            A a1 = new A();
            A a2 = new A();
            A a3 = new A();
            a1.start();
            Thread.sleep(500);
            a2.start();
            a3.start();
            System.out.println(list);
        }
    }

#### 用vector解决 ####

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

package com.tianju.collection;
    
    import java.util.ArrayList;
    import java.util.List;
    import java.util.Vector;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class VectorDemo {
        
        static Vector<Integer> list = new Vector<>();
    
        // 有序性+原子性保证
        volatile static AtomicInteger index =new AtomicInteger(0);
        static class A extends Thread{
        
            @Override
            public void run() {
        
                for (int i = 0; i < 20; i++) {
        
                    list.add(index.incrementAndGet());
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            A a1 = new A();
            A a2 = new A();
            A a3 = new A();
            a1.start();
            a1.join(); // A运行结束，B才能开始运行
            a2.start();
            a2.join();
            a3.start();
            a3.join();
            System.out.println(list);
        }
    }

#### 用Collections.synchronizedList ####

package com.tianju.collection;
    
    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.List;
    import java.util.Vector;
    import java.util.concurrent.atomic.AtomicInteger;
    
    public class CollectionDemo {
        
        static List<Integer> ls = new ArrayList<>();
        static List<Integer> list = Collections.synchronizedList(ls);
    
        // 有序性+原子性保证
        volatile static AtomicInteger index =new AtomicInteger(0);
        static class A extends Thread{
        
            @Override
            public void run() {
        
                for (int i = 0; i < 20; i++) {
        
                    list.add(index.incrementAndGet());
                }
            }
        }
    
        public static void main(String[] args) throws InterruptedException {
        
            A a1 = new A();
            A a2 = new A();
            A a3 = new A();
            a1.start();
            a1.join(); // A运行结束，B才能开始运行
            a2.start();
            a2.join();
            a3.start();
            a3.join();
            System.out.println(list);
        }
    }

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

### 2、表格总结 ###

<table> 
 <thead> 
  <tr> 
   <th>序号</th> 
   <th>线程不安全</th> 
   <th>线程安全</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>1</td> 
   <td>ArrayList</td> 
   <td>Vector/ Collections.synchronizedList(list)</td> 
  </tr> 
  <tr> 
   <td>2</td> 
   <td>HashMap</td> 
   <td>ConcurentHashMap/HashTable</td> 
  </tr> 
  <tr> 
   <td>3</td> 
   <td>HashSet</td> 
   <td>Collections.synchronizedSet()</td> 
  </tr> 
 </tbody> 
</table>

Hashset的底层是HashMap

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

### 3、关于hash算法 ###

比如一开始有蓝色点，经过hash算法之后，得到结果3，然后放到相应的位置；

然后又来了一个红色的点，经过hash算法之后，也是3，此时就顺着蓝色的位置去找；

之前是采用头插法，就是新来的放到蓝色的之前，在1.8之后改成尾插法，放到蓝色的后面；

如果又有新来的，就继续往后面加，此时出现了不利的情况，就是越来越多成了一个很长的链表；

所以就采用了树的结果，这样提高的查找的效率；在1.8中采用的红黑树；

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

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

## 总结 ##

[01302e5f99ae446ea84c04d4a895ea7a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/14180a5ddf4e491a8804ee9e3a59e89b.png
[Java_5_extends Thread_implements Runnable_ _]: https://blog.csdn.net/Pireley/article/details/132425329
[Java_6_ Java_synchronize_ReentrantLock_ _]: https://blog.csdn.net/Pireley/article/details/132432650
[0daf6b6c0d034479af60bd8dded1c68f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/95bd10eb7878412aae850e8dea157db7.png
[681867f0163a4cee9ee0f72cfc6dcd6e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/31e7a53bd3e84b44aef921daa5d65737.png
[44a08fa43a6e417b8a89855ff5c9791b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/207788c59a474fa2acf79b6d54b5f612.png
[b8ae36c5fbb247f2b669ef08d42f25ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/c7e97e34646b401498a9de54caaeb595.png
[2e2629ba1a6440109b3136080ce948d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/a151fc1deee24858b9257add433a8243.png
[46d56dcb7f79431ca173a25f3cb81208.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/d21c4f827a1646a892165cab218a50ee.png
[ffa6ba3e47a1450b83dd73b4f79ed2c4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/152fd79f45ab4e2196bee1fd5d903d72.png
[b14ee1f4f71349d29e76ae63b569afdb.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/a4af95ea47e7429aba24dc0fad8d29cb.png
[e6fcf67aac8443d5887fde2ef87d1fe5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/d01180e182be491fbbc484f125853ad6.png
[a2459384ac00408a88f2e8654640f690.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/5f62128910eb4f9abe89d75530cdf985.png
[ad11ab5cb6514f85ad993c77493cc17d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/acbc351ce8b84cbc855d1b8ca27e5392.png
[d3527b26da9c49e28762a7caa379121f.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/810696a3ec094970835bc69bd65f873e.png
[2f94331774534cae8d7303ced38fd210.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/88ab855f33ff48ff820c5d2df863c1b0.png
[410cbc6e4abc4aa89c3572f88d0fb0b9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/cf0588fc1ad24360b5972d79061107aa.png
[ea6ec42649a640ecbb07c42c5a0aa8ec.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/f787122e07fa4a688bb7de635900d4b3.png
[9257035e5fa449cc927c9fb7f5426e2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/1dd1243ef1154535b4b5408963df337e.png
[ff9f55464812475f8be3bc467a4018b1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/635b5ea13c1a48c6a4f5256afdecfff8.png
[7cce831beccb4dafbdcab38ecab6031a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/0b434b4f35284f56b1ed7ef55b3c16b5.png
[2ec4289cdb014fefaaf28dd65058b191.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/e9bcef03d4084922b6faabf4c7a13625.png
[00e8f4fecd004ae7bdb95177f242bf84.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/ffad5a08aeeb42e9b2910315cf4838e7.png
[1504907fe71f46d98e2f77b3a758a9c3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/ec7d8ff8ef174402b74a89ea0bf8b2df.png
[6c3e464a6f1a45e6a0f9a21b56183886.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/a7e93bcfcd184435aac129525a33fe9a.png
[62a097c2632a4c2895ab3c778ef8cbd1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/6e7e0c9f687840198d3afc27e06f5419.png
[244c47558a1f48ce9711fc6619f800ae.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/52de3fcb694e4ed5b4ac7c7a3394ab8c.png
[0631ad9ef9724f4f91a837fc1806f1d9.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/3fcb3689cd2645e18d80931b7a5b0487.png
[8a296f85af6a4d4a8390fab350aba28b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/cda20372a09c482ba36497aaceb2c159.png
[e9a9fc4a755f4681bca9e9af165bbc80.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/fb584eed0e7a41d2871ec062219a769b.png
[ccfba2bebd5d461190561a4cd8747f4e.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/e1aa1f35e41646c9a0809db54b73ed02.png
[742a4e1ea92544f1bf5f101db3d440d4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/c04259f238254dd7abdadbfa25b124b8.png
[b4b7c4571ec54f538842e8074ea5eb02.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/9d5844dffdf64d58ace8bdd7a53ebcc1.png
[c138462c042f41d284c840f687c87ad1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/385b53831d174e0fa85dfd67ad34c109.png
[514f303f0f29461a882406cfa4f064d2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/680049b8f4cc4ae9b6a45373f0e9fc3f.png
[a6c1dfe726544d55a01cb34548069300.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/02831d9c364b4dc8bf48b74d07e83082.png
[2cc702151baa430aabac9e2d14825553.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/4a5c973f1fdc409b8c4115a33672fbbd.png
[d9c5ebfd3c80427bb1588aa473a17a4a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/c285508bf15047298965e50b86239fdb.png
[ece1f0457740487b9fbedc79fcf468a8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/02/19/063aeee68b1f46e4b2896c95cc76a769.png