java实现延时处理

左手的ㄟ右手 2023-10-11 16:44 35阅读 0赞

*  业务场景：
 *  1.数据库轮询
    
     *  1.1 思路
     *  1.2 实现
        
         *  1.2.1在启动类上添加注解@EnableScheduling，如下图所示：
         *  1.2.2 创建配置类，添加注解@Scheduled
     *  1.3 优缺点
 *  2.JDK的延迟队列
    
     *  2.1 思路
     *  2.2 实现
     *  2.3 优缺点
 *  3.时间轮算法
    
     *  3.1 思路
     *  3.2 实现
        
         *  3.2.1 添加maven依赖
         *  3.2.2 具体实现
     *  3.3 优缺点
 *  4.redis缓存
    
     *  4.1 利用redis的zset
        
         *  4.1.1 添加redis依赖
         *  4.1.2 解决多线程消费同一资源
     *  4.2 使用redis的Keyspace Notifications（键空间机制）
     *  4.3 优缺点
 *  5.使用消息队列
    
     *  5.1 思路
     *  5.2 实现
     *  5.3 优缺点

## 业务场景： ##

> 1.生成订单30分钟未支付，则自动取消，我们该怎么实现呢？  
> 2.生成订单60秒后,给用户发短信

对上述的两个业务场景，我们给一个专业的名字来形容，那就是**延时任务**。那么这里就会产生一个问题，这个延时任务和定时任务的区别究竟在哪里呢？一共有如下几点区别:

*  定时任务有明确的触发时间，延时任务没有
 *  定时任务有执行周期，而延时任务在某事件触发后一段时间内执行，没有执行周期
 *  定时任务一般执行的是批处理操作是多个任务，而延时任务一般是单个任务

下面我们通过判断订单是否超时为例，进行方案分析

## 1.数据库轮询 ##

### 1.1 思路 ###

该方案通常是在小型项目中使用，即通过一个线程定时的去扫描数据库，通过订单时间来判断是否有超时的订单，然后进行update或delete等操作

### 1.2 实现 ###

通过springBoot中的@Schedule进行实现

#### 1.2.1在启动类上添加注解@EnableScheduling，如下图所示： ####

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

#### 1.2.2 创建配置类，添加注解@Scheduled ####

@Controller
    public class UpdateTimeSchedule {
        
       @Scheduled(fixedDelay = 1000 * 10)
        public void work() {
        
      // do your work here
      
    }
    
    }

上例每隔10秒执行一次，设第一次执行开始时时间为 0，如果任务的执行时间是 5 秒，那下次任务的开始时间是 5 + 10 = 15 即第 15 秒。再下一次任务开始执行时间是 15 + 5 + 10 = 30 即第 30 秒，以此类推  
更多操作[点击此处查看][Link 1]

### 1.3 优缺点 ###

优点:简单易行，支持集群操作  
缺点:(1)对服务器内存消耗大  
(2)存在延迟，比如你每隔3分钟扫描一次，那最坏的延迟时间就是3分钟  
(3)假设你的订单有几千万条，每隔几分钟这样扫描一次，数据库损耗极大

## 2.JDK的延迟队列 ##

### 2.1 思路 ###

该方案是利用JDK自带的DelayQueue来实现，这是一个无界阻塞队列，该队列只有在延迟期满的时候才能从中获取元素，放入DelayQueue中的对象，是必须实现Delayed接口的。  
DelayedQueue实现工作流程如下图所示  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]

*  Poll():获取并移除队列的超时元素，没有则返回空
 *  take():获取并移除队列的超时元素，如果没有则wait当前线程，直到有元素满足超时条件，返回结果。

### 2.2 实现 ###

定义一个类OrderDelay实现Delayed

import java.util.concurrent.Delayed;
    
    import java.util.concurrent.TimeUnit;
    
    public class OrderDelay implements Delayed {
        
    
        private String orderId;
    
        private long timeout;
    
        public OrderDelay(String orderId, long timeout) {
        
    
            this.orderId = orderId;
    
            this.timeout = timeout + System.nanoTime();
    
        }
    
        public int compareTo(Delayed other) {
        
    
            if (other == this)
    
                return 0;
    
            OrderDelay t = (OrderDelay) other;
    
            long d = (getDelay(TimeUnit.NANOSECONDS) - t
    
                    .getDelay(TimeUnit.NANOSECONDS));
    
            return (d == 0) ? 0 : ((d < 0) ? -1 : 1);
    
        }
    
        // 返回距离你自定义的超时时间还有多少
    
        public long getDelay(TimeUnit unit) {
        
    
            return unit.convert(timeout - System.nanoTime(), TimeUnit.NANOSECONDS);
    
        }
    
        void print() {
        
    
            System.out.println(orderId + "编号的订单要删除啦。。。。");
    
        }
    
    }

接下来我们新建一个测试类：

import java.util.ArrayList;
    
    import java.util.List;
    
    import java.util.concurrent.DelayQueue;
    
    import java.util.concurrent.TimeUnit;
    
    public class DelayQueueDemo {
        
    
        public static void main(String[] args) {
        
    
            // TODO Auto-generated method stub
    
            List<String> list = new ArrayList<String>();
    
            list.add("00000001");
    
            list.add("00000002");
    
            list.add("00000003");
    
            list.add("00000004");
    
            list.add("00000005");
    
            DelayQueue<OrderDelay> queue = new DelayQueue<OrderDelay>();
    
            long start = System.currentTimeMillis();
    
            for (int i = 0; i < 5; i++) {
        
    
                //延迟三秒取出
    
                queue.put(new OrderDelay(list.get(i),
    
                        TimeUnit.NANOSECONDS.convert(3, TimeUnit.SECONDS)));//入队
    
                try {
        
    
                    queue.take().print();
    
                    System.out.println("After " +
    
                            (System.currentTimeMillis() - start) + " MilliSeconds");
    
                } catch (InterruptedException e) {
        
    
                    // TODO Auto-generated catch block
    
                    e.printStackTrace();
    
                }
    
            }
        }
    }

测试结果如下：  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]

### 2.3 优缺点 ###

*  优点:效率高,任务触发时间延迟低。
 *  缺点:  
    (1)服务器重启后，数据全部消失，怕宕机  
    (2)集群扩展相当麻烦  
    (3)因为内存条件限制的原因，比如下单未付款的订单数太多，那么很容易就出现OOM异常  
    (4)代码复杂度较高

## 3.时间轮算法 ##

### 3.1 思路 ###

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

时间轮算法可以类比于时钟，如上图箭头（指针）按某一个方向按固定频率轮动，每一次跳动称为一个 tick。  
这样可以看出定时轮由个3个重要的属性参数，ticksPerWheel（一轮的tick数），tickDuration（一个tick的持续时间）以及 timeUnit（时间单位）  
例如当ticksPerWheel=60，tickDuration=1，timeUnit=秒，这就和现实中的始终的秒针走动完全类似了。

> 如果当前指针指在1上面，我有一个任务需要4秒以后执行，那么这个执行的线程回调或者消息将会被放在5上。  
> 那如果需要在20秒之后执行怎么办，由于这个环形结构槽数只到8，如果要20秒，指针需要多转2圈。位置是在2圈之后的5上面（20 % 8 + 1）

### 3.2 实现 ###

我们用Netty的HashedWheelTimer来实现

#### 3.2.1 添加maven依赖 ####

<dependency>
                <groupId>io.netty</groupId>
                <artifactId>netty-all</artifactId>
                <version>5.0.0.Alpha2</version>
            </dependency>

#### 3.2.2 具体实现 ####

import io.netty.util.HashedWheelTimer;
    
    import io.netty.util.Timeout;
    
    import io.netty.util.Timer;
    
    import io.netty.util.TimerTask;
    
    import java.util.concurrent.TimeUnit;
    
    public class HashedWheelTimerTest {
        
    
        static class MyTimerTask implements TimerTask{
        
    
            boolean flag;
    
            public MyTimerTask(boolean flag){
        
    
                this.flag = flag;
    
            }
    
            public void run(Timeout timeout) throws Exception {
        
    
                // TODO Auto-generated method stub
    
                System.out.println("要去数据库删除订单了。。。。");
    
                this.flag =false;
    
            }
    
        }
    
        public static void main(String[] argv) {
        
    
            MyTimerTask timerTask = new MyTimerTask(true);
    
            Timer timer = new HashedWheelTimer();
    
            timer.newTimeout(timerTask, 3, TimeUnit.SECONDS);//此处设置在时间轮第几个执行（本代码设置为第3格）
    
            int i = 1;
    
            while(timerTask.flag){
        
    
                try {
        
    
                    Thread.sleep(1000);
    
                } catch (InterruptedException e) {
        
    
                    // TODO Auto-generated catch block
    
                    e.printStackTrace();
    
                }
    
                System.out.println(i+"秒过去了");
    
                i++;
    
            }
    
        }
    
    }

测试结果如下：  
![在这里插入图片描述][f09c9d2f6b1247deaf734157f11ac0ba.png_pic_center]

### 3.3 优缺点 ###

*  优点:效率高,任务触发时间延迟时间比delayQueue低，代码复杂度比delayQueue低。
 *  缺点:  
    (1)服务器重启后，数据全部消失，怕宕机  
    (2)集群扩展相当麻烦  
    (3)因为内存条件限制的原因，比如下单未付款的订单数太多，那么很容易就出现OOM异常

## 4.redis缓存 ##

对于redis缓存的实现我们有两种方式：

*  1.利用redis的zset,zset是一个有序集合，每一个元素(member)都关联了一个score,通过score排序来取集合中的值
 *  2.使用redis的Keyspace Notifications（键空间机制），就是利用该机制可以在key失效之后，提供一个回调，实际上是redis会给客户端发送一个消息。

### 4.1 利用redis的zset ###

添加元素:ZADD key score member \[\[score member\] \[score member\] …\]  
按顺序查询元素:ZRANGE key start stop \[WITHSCORES\]  
查询元素score:ZSCORE key member  
移除元素:ZREM key member \[member …\]  
下面我通过实操来给大家演示一下

添加单个元素
    redis> ZADD page_rank 10 google.com
    添加多个元素
    redis> ZADD page_rank 9 baidu.com 8 bing.com
    (integer) 2

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

按顺序查询元素 0 -1表示查询所有
    ZRANGE page_rank 0 -1 WITHSCORES

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

查询元素的score值
    redis> ZSCORE page_rank bing.com

![在这里插入图片描述][59c4561d79c94cbcb4f908128eeee91e.png_pic_center]

移除单个元素
    redis> ZREM page_rank google.com

![在这里插入图片描述][6ec6f8f7791d4516af77ac633776a4fc.png_pic_center]

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

我们具体将其和和我们要实现的功能联系在一起呢?  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]

#### 4.1.1 添加redis依赖 ####

<dependency>
    			<groupId>org.springframework.boot</groupId>
    			<artifactId>spring-boot-starter-redis</artifactId>
    			<version>1.4.7.RELEASE</version>
    		</dependency>

具体的实现如下：

import java.util.Calendar;
    
    import java.util.Set;
    
    import redis.clients.jedis.Jedis;
    
    import redis.clients.jedis.JedisPool;
    
    import redis.clients.jedis.Tuple;
    
    public class AppTest {
        
    
        private static final String ADDR = "192.168.1.2";
    
        private static final int PORT = 6379;
    
        private static JedisPool jedisPool = new JedisPool(ADDR, PORT);
    
        private static int waitTime = 10;//以10秒为基准
    
        public static Jedis getJedis() {
        
    
            return jedisPool.getResource();
    
        }
    
        //生产者,生成5个订单放进去
    
        public void productionDelayMessage() {
        
            long startTime = System.currentTimeMillis();
            for (int i = 0; i < 5; i++) {
        
    
                //延迟3秒
    
                Calendar cal1 = Calendar.getInstance();
                waitTime += 5;//每个订单之间的间隔为5秒
                cal1.add(Calendar.SECOND, waitTime);
    
                int second3later = (int) (cal1.getTimeInMillis() / 1000);
    
                AppTest.getJedis().zadd("OrderId", second3later, "OID0000001" + i);
                long endTime = System.currentTimeMillis();
    
                System.out.println((endTime - startTime) / 1000 + "s:redis生成了一个订单任务：订单ID为" + "OID0000001" + i);
    
            }
    
        }
    
        //消费者，取订单
    
        public void consumerDelayMessage() {
        
    
            Jedis jedis = AppTest.getJedis();
            long startTime = System.currentTimeMillis();
            while (true) {
        
    
                Set<Tuple> items = jedis.zrangeWithScores("OrderId", 0, 1);
    
                if (items == null || items.isEmpty()) {
        
    
                    System.out.println("当前没有等待的任务");
    
                    try {
        
    
                        Thread.sleep(500);
    
                    } catch (InterruptedException e) {
        
    
                        // TODO Auto-generated catch block
    
                        e.printStackTrace();
    
                    }
    
                    continue;
    
                }
    
                int score = (int) ((Tuple) items.toArray()[0]).getScore();
    
                Calendar cal = Calendar.getInstance();
    
                int nowSecond = (int) (cal.getTimeInMillis() / 1000);
    
                if (nowSecond >= score) {
        
    
                    String orderId = ((Tuple) items.toArray()[0]).getElement();
    
                    jedis.zrem("OrderId", orderId);
                    long endTime = System.currentTimeMillis();
                    System.out.println((endTime - startTime) / 1000 + "s:redis消费了一个任务：消费的订单OrderId为" + orderId);
    
                }
    
            }
    
        }
    
        public static void main(String[] args) {
        
    
            AppTest appTest = new AppTest();
            appTest.productionDelayMessage();//创建消费订单
            appTest.consumerDelayMessage();//由消费者进行消费
    
        }
    
    }

测试结果如下：  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]

通过上述结果我们可以看出每隔5秒消费了一笔订单  
然而上面的实现却有一个致命的问题： 在高并发条件下，多消费者会取到同一个订单号   
我们使用多线程进行测试一下

import java.util.concurrent.CountDownLatch;
    
    public class ThreadTest {
        
    
        private static final int threadNum = 10;//线程数
    
        private static CountDownLatch cdl = new CountDownLatch(threadNum);
    
        static class DelayMessage implements Runnable {
        
    
            public void run() {
        
    
                try {
        
    
                    cdl.await();
    
                } catch (InterruptedException e) {
        
    
                    // TODO Auto-generated catch block
    
                    e.printStackTrace();
    
                }
    
                AppTest appTest = new AppTest();
    
                appTest.consumerDelayMessage();
    
            }
    
        }
    
        public static void main(String[] args) {
        
    
            AppTest appTest = new AppTest();
    
            appTest.productionDelayMessage();
    
            for (int i = 0; i < threadNum; i++) {
        
    
                new Thread(new DelayMessage()).start();
    
                cdl.countDown();
    
            }
    
        }
    
    }

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

可以看出出现了多个线程消费同一个资源的情况，这种情况肯定是不允许的，所以给出两个解决方案让大家参考

*  1.用分布式锁，但是用分布式锁，性能下降了
 *  2.对ZREM的返回值进行判断，只有大于0的时候，才消费数据

由于方案1涉及到java分布式锁的设计，后面我会专门出一期关于java分布式锁的内容讲解，同时也会将第一个方法的内容补全，下面我们先看看如何通过ZREM来进行解决多线程消费同一个订单的问题

#### 4.1.2 解决多线程消费同一资源 ####

我们将consumerDelayMessage()方法中的  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 9]

改为以下内容

if (nowSecond >= score) {
        
    
                    String orderId = ((Tuple) items.toArray()[0]).getElement();
    
                    Long num = jedis.zrem("OrderId", orderId);
                    long endTime = System.currentTimeMillis();
                    if (num != null && num > 0) {
        
                        System.out.println((endTime - startTime) / 1000 + "s:redis消费了一个任务：消费的订单OrderId为" + orderId);
                    }
    
                }

再次进行多线程的测试  
![在这里插入图片描述][watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 10]

### 4.2 使用redis的Keyspace Notifications（键空间机制） ###

在redis的配置文件中(redis.conf)中，加入以下配置

notify-keyspace-events Ex

具体操作代码如下：

package com.example.test.test;
    
    import redis.clients.jedis.JedisPool;
    
    import redis.clients.jedis.JedisPubSub;
    
    public class RedisTest {
        
    
        private static final String ADDR = "192.168.1.2";
    
        private static final int PORT = 6379;
    
        private static JedisPool jedis = new JedisPool(ADDR, PORT);
    
        private static RedisSub sub = new RedisSub();
    
        public static void init() {
        
    
            new Thread(new Runnable() {
        
    
                public void run() {
        
    
                    jedis.getResource().subscribe(sub, "__keyevent@0__:expired");
    
                }
    
            }).start();
    
        }
    
        public static void main(String[] args) throws InterruptedException {
        
    
            init();
    
            for (int i = 0; i < 10; i++) {
        
    
                String orderId = "OID000000" + i;
    
                jedis.getResource().setex(orderId, 3, orderId);
    
                System.out.println(System.currentTimeMillis() + "ms:" + orderId + "订单生成");
    
            }
    
        }
    
        static class RedisSub extends JedisPubSub {
        
    
            public void onMessage(String channel, String message) {
        
    
                System.out.println(System.currentTimeMillis() + "ms:" + message + "订单取消");
    
            }
    
        }
    
    }

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

可以明显看到3秒过后，订单取消了  
但是这种方法有个很大的弊端，redis的pub/sub机制存在一个硬伤，官网内容如下

> Because Redis Pub/Sub is fire and forget currently there is no way to use this feature if your application demands reliable notification of events, that is, if your Pub/Sub client disconnects, and reconnects later, all the events delivered during the time the client was disconnected are lost.

我给大家翻译翻译什么意思

> Redis的发布/订阅目前是即发即弃(fire and forget)模式的，因此无法实现事件的可靠通知。也就是说，如果发布/订阅的客户端断链之后又重连，则在客户端断链期间的所有事件都丢失了。因此，方案二不是太推荐。当然，如果你对可靠性要求不高，可以使用。

### 4.3 优缺点 ###

*  优点:  
    (1)由于使用Redis作为消息通道，消息都存储在Redis中。如果发送程序或者任务处理程序挂了，重启之后，还有重新处理数据的可能性。  
    (2)做集群扩展相当方便  
    (3)时间准确度高
 *  缺点:(1)需要额外进行redis维护

## 5.使用消息队列 ##

### 5.1 思路 ###

我们可以采用rabbitMQ的延时队列。RabbitMQ可以针对Queue和Message设置 x-message-tt，来控制消息的生存时间，如果超时，则消息变为dead letter。

### 5.2 实现 ###

由于该实现篇幅过长，所以我将其单独拿出来，[点击此处查看][Link 2]

### 5.3 优缺点 ###

*  优点: 高效,可以利用rabbitmq的分布式特性轻易的进行横向扩展,消息支持持久化增加了可靠性。
 *  缺点：本身的易用度要依赖于rabbitMq的运维.因为要引用rabbitMq,所以复杂度和成本变

[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/6de3f418c5c147b990875ff414b9e4d3.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[Link 1]: https://blog.csdn.net/zhiyikeji/article/details/105477711
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 1]: https://img-blog.csdnimg.cn/2df27161590240b481b8305cb22d4e0b.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 2]: https://img-blog.csdnimg.cn/1bf47c73f4aa48d59d3db652742049f0.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_17_color_FFFFFF_t_70_g_se_x_16_pic_center]: https://img-blog.csdnimg.cn/8a84da20d3b94db8acd3264f4a725a40.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_17,color_FFFFFF,t_70,g_se,x_16#pic_center
[f09c9d2f6b1247deaf734157f11ac0ba.png_pic_center]: https://img-blog.csdnimg.cn/f09c9d2f6b1247deaf734157f11ac0ba.png#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 3]: https://img-blog.csdnimg.cn/3993089e40b74946aaa8564596631313.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 4]: https://img-blog.csdnimg.cn/ab5dbbc5cde74af5984c9b3471faa8c2.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[59c4561d79c94cbcb4f908128eeee91e.png_pic_center]: https://img-blog.csdnimg.cn/59c4561d79c94cbcb4f908128eeee91e.png#pic_center
[6ec6f8f7791d4516af77ac633776a4fc.png_pic_center]: https://img-blog.csdnimg.cn/6ec6f8f7791d4516af77ac633776a4fc.png#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 5]: https://img-blog.csdnimg.cn/aec73a62ed6145cb8a446e3f0250e759.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 6]: https://img-blog.csdnimg.cn/dfd2ad7860154f72b7c893499ebf9f9b.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 7]: https://img-blog.csdnimg.cn/fadfdb6e1add489db63aa04c51ec807c.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 8]: https://img-blog.csdnimg.cn/619686b7689b4bf3b9f83a242b3a4e3d.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 9]: https://img-blog.csdnimg.cn/6f6d695374884b3e9b0f89398d327634.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 10]: https://img-blog.csdnimg.cn/8f621fe4743443e08cc581448d64efc4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[watermark_type_d3F5LXplbmhlaQ_shadow_50_text_Q1NETiBAWk5pbmVTdW4_size_20_color_FFFFFF_t_70_g_se_x_16_pic_center 11]: https://img-blog.csdnimg.cn/f61744e851a040e6a9bbf4330197f2c4.png?x-oss-process=image/watermark,type_d3F5LXplbmhlaQ,shadow_50,text_Q1NETiBAWk5pbmVTdW4=,size_20,color_FFFFFF,t_70,g_se,x_16#pic_center
[Link 2]: https://blog.csdn.net/zhiyikeji/article/details/121770609