Java并发（2）同步控制与线程池管理

分手后的思念是犯贱 2022-12-05 09:50 168阅读 0赞

## 一、同步控制 ##

**关于java线程的中断：interrupt**

java中的Thread.suspend, Thread.stop等方法都被Deprecated了.

Java 中断机制是一种协作机制，也就是说通过中断并不能直接终止另一个线程，而需要被中断的线程自己处理中断.

java.lang.Thread 类提供了几个方法来操作这个中断状态，这些方法包括：

<table> 
 <tbody> 
 <tr> 
 <td style="width:268px;"> public static boolean&nbsp;interrupted </td> 
 <td style="width:636px;"> 测试当前线程是否已经中断。线程的中断状态&nbsp;由该方法清除。换句话说，如果连续两次调用该方法，则第二次调用将返回 false（在第一次调用已清除了其中断状态之后，且第二次调用检验完中断状态前，当前线程再次中断的情况除外）。 </td> 
 </tr> 
 <tr> 
 <td style="width:268px;"> public boolean&nbsp;isInterrupted() </td> 
 <td style="width:636px;"> 测试线程是否已经中断。线程的中断状态不受该方法的影响。 </td> 
 </tr> 
 <tr> 
 <td style="width:268px;"> public void&nbsp;interrupt() </td> 
 <td style="width:636px;"> 中断线程，将中断状态设置为true。 </td> 
 </tr> 
 </tbody> 
</table>

一个线程在未正常结束之前, 被强制终止是很危险的事情. 因为它可能带来完全预料不到的严重后果比如会带着自己所持有的锁而永远的休眠，迟迟不归还锁等。

**由于有异常抛出，导致线程会释放全部所持有的锁，极可能引起线程安全问题。**

当线程被阻塞的时候，比如被Object.wait, Thread.join和Thread.sleep三种方法之一阻塞时,调用它的interrput()方法.

**如何安全的终止线程：**

除了中断外，还可以加上一个boolean变量来控制是否需要停止任务并终止线程。

class CanCancelThread extends Thread {
     
        private long i;
        private volatile boolean on = true;
     
        @Override
        public void run() {
            while (on && !Thread.currentThread().isInterrupted()) {
                i++;
            }
            System.out.println("Count i=" + i);
        }
     
        public void cancel() {
            on = false;
        }
    }

class Thread3 extends Thread{
        public void run(){  
            while(!Thread.currentThread().isInterrupted()){  
                if(Thread.currentThread().isInterrupted()){  
                    System.out.println("====================.");  
                }  
                else{  
                    System.out.println("Thread is Going...");  
                }
            }  
        }  
    }  
    
    public class Main {
        public static void main(String[] args) throws InterruptedException { // 此处要抛异常
            Thread3 t = new Thread3();  
            t.start();  
            Thread.sleep(100);  
            t.interrupt(); 
        }
    }

while循环有一个决定因素就是需要不停的检查自己的中断状态。当外部线程调用该线程的interrupt 时，使得中断状态置位即变为true。这是该线程将终止循环

### 1. synchronized 功能扩展-重入锁 ###

![20200909154402259.png][]

需要使用的类：

import java.util.concurrent.locks.ReentrantLock;

例子：使用两个线程更新 i

import java.util.concurrent.locks.ReentrantLock;
 
 class ReThread implements Runnable{
 public static ReentrantLock lock = new ReentrantLock();
 public static int i = 0;
 
 public void run(){
 for (int j = 0; j < 1000; j++){
 lock.lock(); // 加锁
 try{
 i ++;
 }finally{
 lock.unlock(); // 释放锁
 }
 }
 }
 }
 
 public class Main {
 public static void main(String[] args) throws InterruptedException {
 ReThread rt = new ReThread();
 Thread t1 = new Thread(rt);
 Thread t2 = new Thread(rt);
 t1.start();
 t2.start();
 t1.join();
 t2.join();
 System.out.println(ReThread.i);
 }
 }

重入锁的几个重要方法

![20200909172002435.png][]

### 2. condition条件 ###

利用condition对象，我们就可以让线程在合适的时间等待，或者在某一个特定的时刻得到通知，继续执行

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70][]

### 3. 允许多个线程访问：semaphore信号量 ###

信号量是都锁的一个扩展，无论是内部锁synchronized还是重入锁ReentrantLock，一次只允许一个线程访问资源，而信号量可以指定多个线程，同时访问某一个资源。

信号量的构造方法：

![20200910093654502.png][]

![20200910093755913.png][]

上述方法的使用说明

![2020091009392171.png][]

一个信号量使用的例子

import java.util.concurrent.Semaphore;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ExecutorService;
 
 
 class MyThread implements Runnable{
 final Semaphore se = new Semaphore(5); 
 public void run(){
 try{
 se.acquire();
 System.out.println(Thread.currentThread().getId() + ": done ");
 se.release();
 
 }catch(InterruptedException e){
 e.printStackTrace();
 }
 }
 }
 
 public class Main {
 public static void main(String[] args) {
 ExecutorService exec = Executors.newFixedThreadPool(20);
 final MyThread se = new MyThread();
 for (int i = 0; i < 20; i++){
 exec.submit(se);
 }
 
 }
 }

### 4. 读写锁：ReadWriteLock ###

读写锁的作用：

![20200910104119486.png][]

但是读的多个线程和 写的多个线程是需要互不干扰的

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 1][]

### 5. 倒计时器：CountDownLatch ###

![20200910110220965.png][]

### 6.循环栅栏：CyclicBarrier ###

![20200910110540403.png][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 2][]

### 7.线程阻塞工具类：LockSupport ###

![2020091011151267.png][]

// 使用该类
    import java.util.concurrent.locks.LockSupport;
    
    // 阻塞 
    LockSupport.park();
    
    // 释放
    LockSupport.unpark(Thread);

## 二、线程复用：线程池的使用 ##

### 1. 为什么要使用线程池 ###

线程过多会带来额外的开销，其中包括创建销毁线程的开销、调度线程的开销等等，同时也降低了计算机的整体性能。线程池维护多个线程，等待监督管理者分配可并发执行的任务。

这种做法，一方面避免了处理任务时创建销毁线程开销的代价，另一方面避免了线程数量膨胀导致的过分调度问题，保证了对内核的充分利用。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 3][]

### 2. 什么是线程池 ###

线程池（Thread Pool）是一种基于池化思想管理线程的工具，经常出现在多线程服务器中，如MySQL。

![20200910133023900.png][]

使用线程池可以带来一系列好处：

*  **降低资源消耗**：通过池化技术重复利用已创建的线程，降低线程创建和销毁造成的损耗。
 *  **提高响应速度**：任务到达时，无需等待线程创建即可立即执行。
 *  **提高线程的可管理性**：线程是稀缺资源，如果无限制创建，不仅会消耗系统资源，还会因为线程的不合理分布导致资源调度失衡，降低系统的稳定性。使用线程池可以进行统一的分配、调优和监控。
 *  **提供更多更强大的功能**：线程池具备可拓展性，允许开发人员向其中增加更多的功能。比如延时定时线程池ScheduledThreadPoolExecutor，就允许任务延期执行或定期执行。

### 3. JDK中的线程池 ###

Excutor架构图

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 4][]

**ThreadPoolExecutor 运行机制：**

![图2 ThreadPoolExecutor运行流程][2 ThreadPoolExecutor]

线程池在内部实际上构建了一个生产者消费者模型，将线程和任务两者解耦，并不直接关联，从而良好的缓冲任务，复用线程。线程池的运行主要分成两部分：任务管理、线程管理。任务管理部分充当生产者的角色，当任务提交后，线程池会判断该任务后续的流转：

（1）直接申请线程执行该任务；

（2）缓冲到队列中等待线程执行；

（3）拒绝该任务。线程管理部分是消费者，它们被统一维护在线程池内，根据任务请求进行线程的分配，当线程执行完任务后则会继续获取新的任务去执行，最终当线程获取不到任务的时候，线程就会被回收。

线程池工厂方法：

![20200910134419148.png][]

线程池工厂方法具体的说明：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 5][]

**1） newFixedThreadPool()** 方法，返回固定数量的线程池

import java.util.concurrent.Executors;
 import java.util.concurrent.ExecutorService;
 
 
 class MyThread implements Runnable{
 public void run(){
 try{
 System.out.println("time: " + System.currentTimeMillis() + ": " +Thread.currentThread().getId() + ": done ");
 Thread.sleep(100);
 } catch (InterruptedException e){
 e.printStackTrace();
 }
 }
 }
 
 public class Main {
 public static void main(String[] args) {
 ExecutorService exec = Executors.newFixedThreadPool(5);
 final MyThread mt = new MyThread();
 for (int i = 0; i < 10; i++){
 exec.submit(mt);
 }
 
 }
 }

**2）newScheduledThreadPool,根据时间计划，对线程进行调度**

主要方法如下：

![20200910141656453.png][]

![20200910142224555.png][]

**3）自定义线程池：ThreadPoolExecutor**

构造函数：

public ThreadPoolExecutor(int corePoolSize,
 int maximumPoolSize,
 long keepAliveTime,
 TimeUnit unit,
 BlockingQueue<Runnable> workQueue,
 ThreadFactory threadFactory,
 RejectedExecutionHandler handler) {
 if (corePoolSize < 0 ||
 maximumPoolSize <= 0 ||
 maximumPoolSize < corePoolSize ||
 keepAliveTime < 0)
 throw new IllegalArgumentException();
 if (workQueue == null || threadFactory == null || handler == null)
 throw new NullPointerException();
 this.corePoolSize = corePoolSize;
 this.maximumPoolSize = maximumPoolSize;
 this.workQueue = workQueue;
 this.keepAliveTime = unit.toNanos(keepAliveTime);
 this.threadFactory = threadFactory;
 this.handler = handler;
 }

构造方法中的字段含义如下：

*  **corePoolSize**：

线程池大小，决定着新提交的任务是新开线程去执行还是放到任务队列中，也是线程池的最最核心的参数。**一般线程池开始时是没有线程的，只有当任务来了并且线程数量小于corePoolSize才会创建线程。**

核心线程数量，当有新任务在execute()方法提交时，会执行以下判断：

所以，任务提交时，判断的顺序为 corePoolSize --> workQueue --> maximumPoolSize。

1.  如果运行的线程少于 corePoolSize，则创建新线程来处理任务，即使线程池中的其他线程是空闲的；
2.  如果线程池中的线程数量大于等于 corePoolSize 且小于 maximumPoolSize，则只有当workQueue满时才创建新的线程去处理任务；
3.  如果设置的corePoolSize 和 maximumPoolSize相同，则创建的线程池的大小是固定的，这时如果有新任务提交，若workQueue未满，则将请求放入workQueue中，等待有空闲的线程去从workQueue中取任务并处理；
4.  如果运行的线程数量大于等于maximumPoolSize，这时如果workQueue已经满了，则通过handler所指定的策略来处理任务；

*  **maximumPoolSize**：最大线程数量，线程池能创建的最大线程数量。
 *  **workQueue**：等待队列，当任务提交时，如果线程池中的线程数量大于等于corePoolSize的时候，把该任务封装成一个Worker对象放入等待队列；
 *  **workQueue**：保存等待执行的任务的阻塞队列，当提交一个新的任务到线程池以后, 线程池会根据当前线程池中正在运行着的线程的数量来决定对该任务的处理方式，主要有以下几种处理方式:
    
    1.  **直接切换**：这种方式常用的队列是SynchronousQueue，但现在还没有研究过该队列，这里暂时还没法介绍；
    2.  **使用无界队列**：一般使用基于链表的阻塞队列LinkedBlockingQueue。如果使用这种方式，那么线程池中能够创建的最大线程数就是corePoolSize，而maximumPoolSize就不会起作用了（后面也会说到）。当线程池中所有的核心线程都是RUNNING状态时，这时一个新的任务提交就会放入等待队列中。
    3.  **使用有界队列**：一般使用ArrayBlockingQueue。使用该方式可以将线程池的最大线程数量限制为maximumPoolSize，这样能够降低资源的消耗，但同时这种方式也使得线程池对线程的调度变得更困难，因为线程池和队列的容量都是有限的值，所以要想使线程池处理任务的吞吐率达到一个相对合理的范围，又想使线程调度相对简单，并且还要尽可能的降低线程池对资源的消耗，就需要合理的设置这两个数量。
        
         *  如果要想降低系统资源的消耗（包括CPU的使用率，操作系统资源的消耗，上下文环境切换的开销等）, 可以设置较大的队列容量和较小的线程池容量, 但这样也会降低线程处理任务的吞吐量。
         *  如果提交的任务经常发生阻塞，那么可以考虑通过调用 setMaximumPoolSize() 方法来重新设定线程池的容量。
         *  如果队列的容量设置的较小，通常需要将线程池的容量设置大一点，这样CPU的使用率会相对的高一些。但如果线程池的容量设置的过大，则在提交的任务数量太多的情况下，并发量会增加，那么线程之间的调度就是一个要考虑的问题，因为这样反而有可能降低处理任务的吞吐量。
 *  **keepAliveTime**：线程池维护线程所允许的空闲时间。当线程池中的线程数量大于corePoolSize的时候，如果这时没有新的任务提交，核心线程外的线程不会立即销毁，而是会等待，直到等待的时间超过了keepAliveTime；
 *  **threadFactory**：它是ThreadFactory类型的变量，用来创建新线程。默认使用Executors.defaultThreadFactory() 来创建线程。使用默认的ThreadFactory来创建线程时，会使新创建的线程具有相同的NORM\_PRIORITY优先级并且是非守护线程，同时也设置了线程的名称。
 *  **handler**：它是RejectedExecutionHandler类型的变量，**表示线程池的饱和策略**。如果阻塞队列满了并且没有空闲的线程，这时如果继续提交任务，就需要采取一种策略处理该任务。线程池提供了4种策略：
    
    1.  AbortPolicy：直接抛出异常，这是默认策略；
    2.  CallerRunsPolicy：用调用者所在的线程来执行任务；
    3.  DiscardOldestPolicy：丢弃阻塞队列中靠最前的任务，并执行当前任务；
    4.  DiscardPolicy：直接丢弃任务；
 *  **unit**：时间单位

execute()方法用来提交任务，执行流程如下：

![18f88b6d9f59e967e101680f9b2b147a.png][]

public void execute(Runnable command) {
 if (command == null)
 throw new NullPointerException();
 /*
 * clt记录着runState和workerCount
 */
 int c = ctl.get();
 /*
 * workerCountOf方法取出低29位的值，表示当前活动的线程数；
 * 如果当前活动线程数小于corePoolSize，则新建一个线程放入线程池中；
 * 并把任务添加到该线程中。
 */
 if (workerCountOf(c) < corePoolSize) {
 /*
 * addWorker中的第二个参数表示限制添加线程的数量是根据corePoolSize来判断还是maximumPoolSize来判断；
 * 如果为true，根据corePoolSize来判断；
 * 如果为false，则根据maximumPoolSize来判断
 */
 if (addWorker(command, true))
 return;
 /*
 * 如果添加失败，则重新获取ctl值
 */
 c = ctl.get();
 }
 /*
 * 如果当前线程池是运行状态并且任务添加到队列成功
 */
 if (isRunning(c) && workQueue.offer(command)) {
 // 重新获取ctl值
 int recheck = ctl.get();
 // 再次判断线程池的运行状态，如果不是运行状态，由于之前已经把command添加到workQueue中了，
 // 这时需要移除该command
 // 执行过后通过handler使用拒绝策略对该任务进行处理，整个方法返回
 if (! isRunning(recheck) && remove(command))
 reject(command);
 /*
 * 获取线程池中的有效线程数，如果数量是0，则执行addWorker方法
 * 这里传入的参数表示：
 * 1. 第一个参数为null，表示在线程池中创建一个线程，但不去启动；
 * 2. 第二个参数为false，将线程池的有限线程数量的上限设置为maximumPoolSize，添加线程时根据maximumPoolSize来判断；
 * 如果判断workerCount大于0，则直接返回，在workQueue中新增的command会在将来的某个时刻被执行。
 */
 else if (workerCountOf(recheck) == 0)
 addWorker(null, false);
 }
 /*
 * 如果执行到这里，有两种情况：
 * 1. 线程池已经不是RUNNING状态；
 * 2. 线程池是RUNNING状态，但workerCount >= corePoolSize并且workQueue已满。
 * 这时，再次调用addWorker方法，但第二个参数传入为false，将线程池的有限线程数量的上限设置为maximumPoolSize；
 * 如果失败则拒绝该任务
 */
 else if (!addWorker(command, false))
 reject(command);
 }

1. 如果`workerCount < corePoolSize`，则创建并启动一个线程来执行新提交的任务；
2. 如果`workerCount >= corePoolSize`，且线程池内的阻塞队列未满，则将任务添加到该阻塞队列中；
3. 如果`workerCount >= corePoolSize && workerCount < maximumPoolSize`，且线程池内的阻塞队列已满，则创建并启动一个线程来执行新提交的任务；
4. 如果`workerCount >= maximumPoolSize`，并且线程池内的阻塞队列已满, 则根据拒绝策略来处理该任务, 默认的处理方式是直接抛异常。

**4）线程池线程数量的选择**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 6][]

\--------------------------- end ---------------------------

### 项目推荐： ###

**[2000多G的计算机各行业电子资源分享（持续更新）][2000_G]**

**[2020年微信小程序全栈项目之喵喵交友【附课件和源码】][2020]**

**[Spring Boot开发小而美的个人博客【附课件和源码】][Spring Boot]**

**[Java微服务实战296集大型视频-谷粒商城【附代码和课件】][Java_296_-]**

**[Java开发微服务畅购商城实战【全357集大项目】-附代码和课件][Java_357_-]**

**[最全最详细数据结构与算法视频-【附课件和源码】][-]**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]

\-----------------------------------------------------------------------------

[20200909154402259.png]: /images/20221123/65e12be737794ccb8a80004735095e47.png
[20200909172002435.png]: /images/20221123/07cf194d3aca4665892da41e72132e5e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70]: /images/20221123/7365eec7ff5a42c693f94e84b0d58ec4.png
[20200910093654502.png]: /images/20221123/1544076ef33747ef9cd661413bff8aa1.png
[20200910093755913.png]: /images/20221123/864a609e831945629c1015949c76542b.png
[2020091009392171.png]: /images/20221123/f2ef5441fe7d4838a028e3e9a2f090bd.png
[20200910104119486.png]: /images/20221123/879278ee0441470893129a4274b60db1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 1]: /images/20221123/19097a8b69304acf8a1cbac2e3c3c82d.png
[20200910110220965.png]: /images/20221123/b13a1315fc144bd7ac50854980a17cde.png
[20200910110540403.png]: /images/20221123/36c9d1c5d50449c2a1c50cac8a9190cc.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 2]: /images/20221123/1b0bbb56cd36463b9b4324bf3f1b4184.png
[2020091011151267.png]: /images/20221123/9f8eb19531a3409b9a34c8438a83dc90.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 3]: /images/20221123/bf745b30b39b4a9fb2b8db5a45ef4683.png
[20200910133023900.png]: /images/20221123/a352b4b4aa964c14a41685242ed5e6af.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 4]: /images/20221123/18c116487e3d4b6faee132d34eeb4819.png
[2 ThreadPoolExecutor]: /images/20221123/0d9128f0de8740ffad9111a11d4ff231.png
[20200910134419148.png]: /images/20221123/888754d7ff214139af58eaefb093a2e5.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 5]: /images/20221123/7fe4add1912640699232c7a2f30c691f.png
[20200910141656453.png]: /images/20221123/30d44ff1b9b84cce81a25b1a0905d890.png
[20200910142224555.png]: /images/20221123/4701dbfc8819458babfe2518b6c52fab.png
[18f88b6d9f59e967e101680f9b2b147a.png]: /images/20221123/932d18fc768f4b4d978e27d59f6dee24.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70 6]: /images/20221123/26eacc8bcb80429491e4591128a6d7ce.png
[2000_G]: https://mp.weixin.qq.com/s/sP4JgGWkCzpgwKr9sAV2_Q
[2020]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487704&idx=1&sn=5f4b2127c4d49fd07ae072a0721424a2&chksm=e8036fc2df74e6d489c4aa9b06f917ef7cee6027f13e150fca53cf79d5d188d4ccc1af49e098&scene=21#wechat_redirect
[Spring Boot]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487798&idx=2&sn=ac0293b996521b872a9dba5fbb3e65e6&chksm=e8036e2cdf74e73aba104a9a994a5b2e31483e8dcbe0f1d9936f6d5173b887e1560f59d2819c&scene=21#wechat_redirect
[Java_296_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487674&idx=1&sn=7aff0bdf2bb727303f3d3618995aef21&chksm=e8036fa0df74e6b6d872c7e6ece179c524ed463a4a6b74c96875475c9a3d5ddb903427dd993b&scene=21#wechat_redirect
[Java_357_-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247486376&idx=1&sn=d1fef270c463ea8ac663f6fbfedd70a0&chksm=e80374b2df74fda4d3bafba878a106a19e18c5fcda266008f4f37975847a21bc612ffcd5ff39&scene=21#wechat_redirect
[-]: https://mp.weixin.qq.com/s?__biz=MzIyNTI3NDQ4NQ==&mid=2247487750&idx=1&sn=747bccbb5f5ea6b58915198de40da777&chksm=e8036e1cdf74e70ae97a5e8e265b49d7236d904d291203309159d07ba1724033062c0e370843&scene=21#wechat_redirect
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQwNTg3NTc1_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/cc830b5272bc4608bd215727415bc10d.png