分布式锁【分布式锁概述、业务介绍、创建SpringBoot项目】(一)-全面详解（学习总结---从入门到深化）

待我称王封你为后i 2023-10-13 16:54 140阅读 0赞

### ![31e058910d2f4cecaf6ee8b8af1ceb97.gif][] ###

![6e99037ca20347528209c8049dbddbbb.png][]

**目录**

分布式锁概述

分布式锁问题\_业务介绍

分布式锁问题\_创建SpringBoot项目

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

### 分布式锁概述 ###

![b3ca6d57e590422682f713f567026f3d.png][]

**为什么需要分布式锁**

![839c1d5c91d94807bb3ad5556cf71e34.png][]

> 在单机部署的系统中，使用线程锁来解决高并发的问题，多线程访问共享变量的问题达到数据一致性，如使用synchornized、 ReentrantLock等。

![ca905a67ec7a402d8f3e30a3b0fcc9b6.png][]

但是在后端集群部署的系统中，程序在不同的JVM虚拟机中运行， 且因为synchronized或ReentrantLock都只能保证同一个JVM进程 中保证有效，所以这时就需要使用分布式锁了。

**什么是分布式锁**

分布式锁其实就是，控制分布式系统不同进程共同访问共享资源的 一种锁的实现。如果不同的系统或同一个系统的不同主机之间共享 了某个临界资源，往往需要互斥来防止彼此干扰，以保证一致性。

![9aef18c14925453aa9be332db6e9a060.png][]

**分布式锁的特点**

![6292d89f62ce4cae899dfb12dc5f3d37.png][]

### 分布式锁问题\_业务介绍 ###

**案列介绍**

![6322e17a51354afbbb83bd7c53e08d9c.png][]

**技术选型**

![ae38c7901c2740ddb43fb9303b57dfad.png][]

**创建表**

**创建订单表**

CREATE TABLE `t_order`  (
      `id` varchar(255) CHARACTER SET utf8 COLLATE
    utf8_general_ci NOT NULL,
      `order_status` int(1) NULL DEFAULT NULL
    COMMENT '订单状态 1 待支付 2已支付',
      `receiver_name` varchar(255) CHARACTER SET
    utf8 COLLATE utf8_general_ci NULL DEFAULT NULL
    COMMENT '收货人名字',
      `receiver_mobile` varchar(255) CHARACTER SET
    utf8 COLLATE utf8_general_ci NULL DEFAULT NULL
    COMMENT '收货人手机',
      `order_amount` decimal(10, 2) NULL DEFAULT
    NULL COMMENT '订单价格',
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE
    = utf8_general_ci ROW_FORMAT = Dynamic;

**创建商品表**

CREATE TABLE `product`  (
      `id` int(11) NOT NULL,
      `product_name` varchar(255) CHARACTER SET
    utf8 COLLATE utf8_general_ci NULL DEFAULT NULL
    COMMENT '商品名字',
      `price` decimal(10, 2) NULL DEFAULT NULL
    COMMENT '商品价格',
      `count` bigint(50) UNSIGNED NULL DEFAULT NULL
    COMMENT '库存',
      `product_desc` varchar(255) CHARACTER SET
    utf8 COLLATE utf8_general_ci NULL DEFAULT NULL
    COMMENT '商品描述',
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE
    = utf8_general_ci ROW_FORMAT = Dynamic;
    -- ----------------------------
    -- Records of product
    -- ----------------------------
    INSERT INTO `product` VALUES (1001,'拯救者',100.00, 5,'好用实惠', 1);

**创建订单商品关联表**

CREATE TABLE `order_item`  (
      `id` varchar(255) CHARACTER SET utf8 COLLATE
    utf8_general_ci NOT NULL,
      `order_id` varchar(36) CHARACTER SET utf8
    COLLATE utf8_general_ci NULL DEFAULT NULL
    COMMENT '订单ID',
      `produce_id` int(11) NULL DEFAULT NULL
    COMMENT '商品ID',
      `purchase_price` decimal(10, 2) NULL DEFAULT
    NULL COMMENT '购买价格',
      `purchase_num` int(11) NULL DEFAULT NULL
    COMMENT '购买数量',
      PRIMARY KEY (`id`) USING BTREE
    ) ENGINE = InnoDB CHARACTER SET = utf8 COLLATE
    = utf8_general_ci ROW_FORMAT = Dynamic;

### 分布式锁问题\_创建SpringBoot项目 ###

![3c205a23e7a049e99a728c92382f7513.png][]

引入依赖

<dependencies>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-boot-starter</artifactId>
                <version>3.4.2</version>
            </dependency>
            <dependency>
                <groupId>mysql</groupId>
                <artifactId>mysql-connector-java</artifactId>
                <scope>runtime</scope>
            </dependency>
            <dependency>
                <groupId>org.projectlombok</groupId>
                <artifactId>lombok</artifactId>
                <optional>true</optional>
            </dependency>
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
                <exclusions>
                    <exclusion>
                        <groupId>org.junit.vintage</groupId>
                        <artifactId>junit-vintage-engine</artifactId>
                    </exclusion>
                </exclusions>
            </dependency>
            <dependency>
                <groupId>com.baomidou</groupId>
                <artifactId>mybatis-plus-generator</artifactId>
                <version>3.5.2</version>
            </dependency>
            
            <dependency>
                <groupId>org.apache.velocity</groupId>
                <artifactId>velocity-engine-core</artifactId>
                <version>2.0</version>
            </dependency>
        </dependencies>

**修改配置文件**

spring:
     application:
       name: lock
     datasource:
       url: jdbc:mysql://192.168.66.100:3306/distribute?serverTimezone=UTC
       username: root
       password01: 123456
       driver-class-name: com.mysql.cj.jdbc.Driver
    server:
     port: 9091

**编写主启动类**

@Slf4j
    @MapperScan("com.tong.lock.mapper")
    @SpringBootApplication
    public class LockdemoApplication {
        public static void main(String[] args) {
           SpringApplication.run(LockdemoApplication.class, args);
            log.info("************** 分布式锁 **************");
       }
    }

**代码生成**

使用Mybaits Plus生成订单表、商品表、订单商品关联表的相关代码。

package com.tong.lock.utils;
    import com.baomidou.mybatisplus.generator.FastAutoGenerator;
    import com.baomidou.mybatisplus.generator.config.rules.NamingStrategy;
    import java.util.Arrays;
    import java.util.List;
    public class CodeGenerator {
     public static void main(String[] args) {
          FastAutoGenerator.create("jdbc:mysql://192.168.66.100:3306/distribute", "root", "123456")
                   .globalConfig(builder -> {
                        builder.author("itbaizhan")// 设置作者
                               .commentDate("MMdd") // 注释日期格式
                               .outputDir(System.getProperty("user.dir")+ "/src/main/java/") // 指定输出目录
                               .fileOverride(); //覆盖文件
                   })
                    // 包配置
                   .packageConfig(builder -> {
                      builder.parent("com.itbaizhan.lock") // 包名前缀
                               .entity("entity")//实体类包名
                               .mapper("mapper")//mapper接口包名
                               .service("service"); //service包名
                   })
                   .strategyConfig(builder -> {
                        List<String> strings = Arrays.asList("t_order");
                        // 设置需要生成的表名
                        builder.addInclude(strings)
                                // 开始实体类配置
                               .entityBuilder()
                                // 开启lombok模型
                               .enableLombok()
                                //表名下划线转驼峰
                               .naming(NamingStrategy.underline_to_camel)
                                //列名下划线转驼峰
                               .columnNaming(NamingStrategy.underline_to_camel);
                   })
                   .execute();
       }
    }

**编写创建订单接口**

public interface ITOrderService extends IService<TOrder> {
        /**
         * 创建订单
         * @return
         */
        String createOrder(Integer productId,Integer count);
    }

**实现创建订单接口**

package com.tong.lock.service.impl;
    import com.tong.lock.entity.OrderItem;
    import com.tong.lock.entity.Product;
    import com.tong.lock.entity.TOrder;
    import com.tong.lock.mapper.OrderItemMapper;
    import com.tong.lock.mapper.ProductMapper;
    import com.tong.lock.mapper.TOrderMapper;
    import com.tong.lock.service.ITOrderService;
    import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    import org.springframework.stereotype.Service;
    import org.springframework.transaction.annotation.Transactional;
    import javax.annotation.Resource;
    import java.math.BigDecimal;
    import java.util.concurrent.locks.ReentrantLock;
    /**
    * <p>
    * 服务实现类
    * </p>
    *
    * @author tong
    * @since 05-25
    */
    @Service
    public class TOrderServiceImpl extends ServiceImpl<TOrderMapper, TOrder> implements ITOrderService {
        @Resource
        OrderItemMapper orderItemMapper;
        @Resource
        ProductMapper productMapper;    
        /**
         * 创建订单
         * @return
         */
        @Transactional(rollbackFor = Exception.class)
        @Override
        public  String createOrder(Integer productId,Integer count) {
      // 1、根据商品id查询商品信息
                Product product = productMapper.selectById(productId);
                // 2、判断商品是否存在
                if (product == null){
                    throw new RuntimeException("购买商品不存在:" + productId + "不存在");
               }
                // 3、校验库存
                if( count > product.getCount() ){
                    throw   new RuntimeException("商品" + productId + "仅剩" + product.getCount() + "件,无法购买");
               }
                // 4、计算库存
                Integer leftCount = product.getCount() - count;
                // 5、更新库存
                product.setCount(leftCount);
                productMapper.updateById(product);
                // 6、 创建订单
                TOrder order = new TOrder();
                order.setOrderStatus(1);//待处理
                order.setReceiverName("张三");
                order.setReceiverMobile("18587781068");
                order.setOrderAmount(product.getPrice().multiply(new BigDecimal(count)));//订单价格
                baseMapper.insert(order);
                // 7、 创建订单和商品关系数据
                OrderItem orderItem = new OrderItem();
                orderItem.setOrderId(order.getId());
                orderItem.setProduceId(product.getId());
                orderItem.setPurchasePrice(product.getPrice());
                orderItem.setPurchaseNum(count);
                orderItemMapper.insert(orderItem);
                return order.getId();
       }
    }

**编写创建订单api接口**

@RestController
    @RequestMapping("/order")
    public class OrderController {
        @Autowired
        private ITOrderService iOrderService;
        /**
         * 创建订单
         * @param productId 商品id
         * @param count 商品数量
         * @return
         */
        @PostMapping("/create")
        public String createOrder(Integer productId,Integer count){
          return iOrderService.createOrder(productId,count);
       }
    }

**测试订单**

![a5204a42442a4a3590edb18c847511e5.png][]

**复习：**

### Single Thread Execution 设计模式 ###

**机场过安检**

> Single Thread Execution 模式是指在同一时刻只能有一个线程去访问共享资源，就 像独木桥一样每次只允许一人通行，简单来说， Single Thread Execution 就是采用排 他式的操作保证在同一时刻只能有一个线程访问共享资源。 相信大家都有乘坐飞机的经历，在进入登机口之前必须经过安全检査，安检口类似于独木桥，每次只能通过一个人，工作人员除了检査你的登机牌以外，还要联网检查身份证信息以及是否携带危险物品，如下图所示。

![caf1aa422f0e48a5b452b997f1ca7559.png][]

**非线程安全**

先模拟一个非线程安全的安检口类，旅客（线程）分别手持登机牌和身份证接受工作人 员的检查，示例代码如下所示。

package com.tong.chapter14;
    public class FlightSecurity {
        private int count = 0;
        private String boardingPass = "null";// 登机牌
        private String idCard = "null";// 身份证
        public void pass(String boardingPass, String idCard) {
                 this.boardingPass = boardingPass;
                 this.idCard = idCard;
                 this.count++;
                 check();
    }
        private void check() {
        // 简单的业务，当登机牌和身份证首位不相同时则表示检查不通过
        if (boardingPass.charAt(0) != idCard.charAt(0)) {
              throw new RuntimeException("-----Exception-----" + toString());
       }
    }
    @Override
    public String toString() {
               return "FlightSecurity{" + "count=" + count + ", boardingPass='" + boardingPass + '\'' + ", idCard='" + idCard + '\'' + '}';
        }
    }

> FlightSecurity 比较简单，提供了一个 pass 方法，将旅客的登机牌和身份证传递给 pass 方法，在 pass 方法中调用 check 方法对旅客进行检查，检查的逻辑也足够的简单， 只需要检测登机牌和身份证首位是否相等（当然这样在现实中非常不合理，但是为了使测试简单我们约定这么做），我们看以下代码所示的测试。

package com.tong.chapter14;
    public class FlightSecurityTest {
           static class Passengers extends Thread {
           // 机场安检类
           private final FlightSecurity flightSecurity;
           // 旅客身份证
           private final String idCard;
           // 旅客登机牌
           private final String boardingPass;
           public Passengers(FlightSecurity flightSecurity, String idCard, String boardingPass) {
           this.flightSecurity = flightSecurity;
           this.idCard = idCard;
           this.boardingPass = boardingPass;
    }
    @Override
    public void run() {
       while (true) {
             // 旅客不断地过安检
             flightSecurity.pass(boardingPass, idCard);
           }
        }
    }
    public static void main(String[] args) {
          // 定义三个旅客，身份证和登机牌首位均相同
           final FlightSecurity flightsecurity = new FlightSecurity();
           new Passengers(flightsecurity, "Al23456", "AF123456").start();
           new Passengers(flightsecurity, "B123456", "BF123456").start();
           new Passengers(flightsecurity, "C123456", "CF123456").start();
        }
    }

> 看起来每一个客户都是合法的，因为每一个客户的身份证和登机牌首字母都一样，运行 上面的程序却出现了错误，而且错误的情况还不太一样，运行多次，发现了两种类型的错误信息，程序输出如下：

java.lang.RuntimeException: -----Exception-----FlightSecurity{count=218,boardingPass='AF123456', idCard='B123456'}
    java.lang.RuntimeException: -----Exception-----FlightSecurity{count=676,boardingPass='BF123456',

> 首字母相同检查不能通过和首字母不相同检查不能通过，为什么会出现这样的情况呢？ 首字母相同却不能通过？更加奇怪的是传入的参数明明全都是首字母相同的，为什么会出现首字母不相同的错误呢。

**问题分析**

**首字母相同却未通过检查**

> 1)线程 A 调用 pass 方法，传人”A123456”“AF123456”并且对 idcard 赋值成功，由 于 CPU 调度器时间片的轮转，CPU 的执行权归 B 线程所有。
> 
> 2) 线程 B 调用 pass 方法，传入”B123456”“BF123456”并且对 idcard 赋值成功， 覆盖 A 线程赋值的 idCard。
> 
> 3)线程 A 重新获得 CPU 的执行权，将 boardingPass 赋于 AF123456,因此 check 无 法通过。
> 
> 4)在输出 toString 之前，B 线程成功将 boardingPass 覆盖为 BF123456。

**为何出现首字母不相同的情况**

> 1)线程 A 调用 pass 方法，传入”A123456”“AF123456”并且对 id Card 赋值成功，由 于 CPU 调度器时间片的轮转，CPU 的执行权归 B 线程所有。
> 
> 2)线程 B 调用 pass 方法，传入”B123456”“BF123456”并且对 id Card 赋值成功，覆 盖 A 线程赋值的 idCard。
> 
> 3)线程 A 重新获得 CPU 的执行权，将 boardingPass 赋于 AF123456,因此 check 无 法通过。
> 
> 4)线程 A 检查不通过，输出 idcard=”A123456”和 boardingPass=”BF123456”。

###  ###

### 线程安全 ###

> 上面出现的问题说到底就是数据同步的问题，虽然线程传递给 pass 方法的两个参数能 够百分之百地保证首字母相同，可是在为 FlightSecurity 中的属性赋值的时候会出现多个线程交错的情况，结合我们之前所讲内容可知，需要对共享资源增加同步保护，改进代码如下。

public synchronized void pass(String boardingPass, String idCard) {
           this.boardingPass = boardingPass;
           this.idCard = idCard;
           this.count++;
           check();
    }

> 修改后的 pass 方法，无论运行多久都不会再出现检查出错的情况了，为什么只在 pas 方法增加 synchronized 关键字， check 以及 toString 方法都有对共享资源的访问，难道它们不加同步就不会引起错误么？由于 check 方法是在 pass 方法中执行的，pass 方法加同步已经保证了 single thread execution，因此 check 方法不需要增加同步， toString 方法原因与此相同。

何时适合使用 single thread execution 模式呢？答案如下。

> A. 多线程访问资源的时候，被 synchronized 同步的方法总是排他性的。
> 
> B. 多个线程对某个类的状态发生改变的时候，比如 Flightsecurity 的登机牌以及身 份证。

> 在 Java 中经常会听到线程安全的类和线程非安全的类，所谓线程安全的类是指多个线 程在对某个类的实例同时进行操作时，不会引起数据不一致的问题，反之则是线程非安全的类，在线程安全的类中经常会看到 synchronized 关键字的身影

### Future 设计模式 ###

> Future 模式有点类似于商品订单。比如在网购时，当看重某一件商品事，就可以提交 订单，当订单处理完成后，在家里等待商品送货上门即可。或者说更形象的我们发送 Ajax 请求的时候，页面是异步的进行后台处理，用户无须一直等待请求的结果，可以继续浏览或 操作其他内容。

![a165acab288e49148ebd3d8b98e74c92.png][]

### Master-Worker 设计模式 ###

> Master- Worker 模式是常用的并行计算模式。它的核心思想是系统由两类进程协作工 作： Master 进程和 Worker 进程。 Master 负责接收和分配任务，Worker 负责处理子任 务。当各个 Worker-子进程处理完成后，会将结果返回给 Master，由 Master 做归纳和总 结。其好处是能将一个大任务分解成若干个小任务，并行执行，从而提高系统的吞吐量。

![189ce00238ef4fb0b953044e16bae2c1.png][]

具体代码实现逻辑图如下：

![5311e41181524b6c8a5460301490f180.png][]

### 生产者消费者设计模式 ###

> 生产者和消费者也是一个非常经典的多线程模式，我们在实际开发中应用非常广泛的思 想理念。在生产消费模式中：通常由两类线程，即若干个生产者的线程和若干个消费者的线程。生产者线程负责提交用户请求，消费者线程则负责具体处理生产者提交的任务，在生产者和消费者之间通过共享内存缓存区进行通信。

![216effa6b4b448f5a6e4db06eb364df3.png][]

**具体代码逻辑实现思路：**

![6acc750d9f8a4f339df6fe1e87770353.png][]

Immutable 不可变对象设计模式

不可变对象一定是线程安全的。

**关于时间日期 API 线程不安全的问题**

> 想必大家对 SimpleDateFormat 并不陌生。SimpleDateFormat 是 Java 中一个非常 常用的类，该类用来对日期字符串进行解析和格式化输出，但如果使用不小心会导致非常微 妙和难以调试的问题，因为 DateFormat 和 SimpleDateFormat 类不都是线程安全的， 在多线程环境下调用 format() 和 parse() 方法应该使用同步代码来避免问题。关于时间日期 API 的线程不安全问题直到 JDK8 出现以后才得到解决。

关于线程不安全的代码示例如下：

package com.tong.chapter18.demo01;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    import java.util.concurrent.*;
    public class SimpleDateFormatThreadUnsafe {
    public static void main(String[] args) throws ExecutionException,
    InterruptedException {
          // 初始化时间日期 API
          SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
          // 创建任务线程，执行任务将字符串转成指定格式日期
          Callable<Date> task = () -> sdf.parse("20200808");
          // 创建线程池，数量为 10
          ExecutorService pool = Executors.newFixedThreadPool(10);
          // 构建结果集
          List<Future<Date>> results = new ArrayList<>();
          // 开始执行任务线程，将结果添加至结果集
          for (int i = 0; i < 10; i++) {
                 results.add(pool.submit(task));
           }
          // 打印结果集中的内容
          // 在任务线程执行过程中并且访问结果集内容就会报错
          for (Future<Date> future : results) {
                 System.out.println(future.get());
         }
          // 关闭线程池
            pool.shutdown();
        }
    }

运行结果如下：

![f8383bb4016c461a89d7cb332ca6bfbe.png][]

我们先自己来解决一下这个问题，线程不安全，我给它放到 ThreadLocal 中是否可行呢？

package com.tong.chapter18.demo01;
    import java.text.DateFormat;
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    /**
    * 将每次需要格式转换的参数都放入 ThreadLocal 中进行
    */
    public class DateFormatThreadLocal {
          private static final ThreadLocal<DateFormat> df = ThreadLocal.withInitial(() -> new SimpleDateFormat("yyyyMMdd"));
          public static Date convert(String source) throws ParseException {
             return df.get().parse(source);
        }
    }

然后格式化日期代码如下：

package com.tong.chapter18.demo01;
    import java.text.SimpleDateFormat;
    import java.util.ArrayList;
    import java.util.Date;
    import java.util.List;
    import java.util.concurrent.*;
    public class SimpleDateFormatThreadSafe {
         public static void main(String[] args) throws ExecutionException,InterruptedException {
            // 初始化时间日期 API
            SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");
            // 创建任务线程，执行任务将字符串转成指定格式日期
            //Callable<Date> task = () -> sdf.parse("20191020");
            // 使用 ThreadLocal 处理非线程安全
            Callable<Date> task = () -> DateFormatThreadLocal.convert("20191020");
            // 创建线程池，数量为 10
             ExecutorService pool = Executors.newFixedThreadPool(10);
            // 构建结果集
             List<Future<Date>> results = new ArrayList<>();
            // 开始执行任务线程，将结果添加至结果集
             for (int i = 0; i < 10; i++) {
                   results.add(pool.submit(task));
              }
            // 打印结果集中的内容
            // 在任务线程执行过程中并且访问结果集内容就会报错
             for (Future<Date> future : results) {
                   System.out.println(future.get());
              }
             // 关闭线程池
             pool.shutdown();
        }
    }

上面的程序不管运行多少次都不会再出现线程不安全的问题。

### 定义不可变对象的策略 ###

如何定义不可变对象呢？官方文档描述如下：

![f4cd82c7dca741d6b97a3d1b609940ae.png][]

参考官网文档后设计一个不可变对象，如下：

package com.tong.chapter18.demo02;
    public final class Person {
           private final String name;
           private final String address;
    
           public Person(final String name, final String address) {
                this.name = name;
                this.address = address;
            }
    
           public String getName() {
                 return name;
            }
    
           public String getAddress() 
                return address;
            }
    @Override
    public String toString() {
           return "Person{" + "name='" + name + '\'' + ", address='" + address + '\'' + '}';
      }
    }

[31e058910d2f4cecaf6ee8b8af1ceb97.gif]: https://img-blog.csdnimg.cn/31e058910d2f4cecaf6ee8b8af1ceb97.gif
[6e99037ca20347528209c8049dbddbbb.png]: https://img-blog.csdnimg.cn/6e99037ca20347528209c8049dbddbbb.png
[b3ca6d57e590422682f713f567026f3d.png]: https://img-blog.csdnimg.cn/b3ca6d57e590422682f713f567026f3d.png
[839c1d5c91d94807bb3ad5556cf71e34.png]: https://img-blog.csdnimg.cn/839c1d5c91d94807bb3ad5556cf71e34.png
[ca905a67ec7a402d8f3e30a3b0fcc9b6.png]: https://img-blog.csdnimg.cn/ca905a67ec7a402d8f3e30a3b0fcc9b6.png
[9aef18c14925453aa9be332db6e9a060.png]: https://img-blog.csdnimg.cn/9aef18c14925453aa9be332db6e9a060.png
[6292d89f62ce4cae899dfb12dc5f3d37.png]: https://img-blog.csdnimg.cn/6292d89f62ce4cae899dfb12dc5f3d37.png
[6322e17a51354afbbb83bd7c53e08d9c.png]: https://img-blog.csdnimg.cn/6322e17a51354afbbb83bd7c53e08d9c.png
[ae38c7901c2740ddb43fb9303b57dfad.png]: https://img-blog.csdnimg.cn/ae38c7901c2740ddb43fb9303b57dfad.png
[3c205a23e7a049e99a728c92382f7513.png]: https://img-blog.csdnimg.cn/3c205a23e7a049e99a728c92382f7513.png
[a5204a42442a4a3590edb18c847511e5.png]: https://img-blog.csdnimg.cn/a5204a42442a4a3590edb18c847511e5.png
[caf1aa422f0e48a5b452b997f1ca7559.png]: https://img-blog.csdnimg.cn/caf1aa422f0e48a5b452b997f1ca7559.png
[a165acab288e49148ebd3d8b98e74c92.png]: https://img-blog.csdnimg.cn/a165acab288e49148ebd3d8b98e74c92.png
[189ce00238ef4fb0b953044e16bae2c1.png]: https://img-blog.csdnimg.cn/189ce00238ef4fb0b953044e16bae2c1.png
[5311e41181524b6c8a5460301490f180.png]: https://img-blog.csdnimg.cn/5311e41181524b6c8a5460301490f180.png
[216effa6b4b448f5a6e4db06eb364df3.png]: https://img-blog.csdnimg.cn/216effa6b4b448f5a6e4db06eb364df3.png
[6acc750d9f8a4f339df6fe1e87770353.png]: https://img-blog.csdnimg.cn/6acc750d9f8a4f339df6fe1e87770353.png
[f8383bb4016c461a89d7cb332ca6bfbe.png]: https://img-blog.csdnimg.cn/f8383bb4016c461a89d7cb332ca6bfbe.png
[f4cd82c7dca741d6b97a3d1b609940ae.png]: https://img-blog.csdnimg.cn/f4cd82c7dca741d6b97a3d1b609940ae.png