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

分布式锁概述

分布式锁问题_业务介绍

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

分布式锁概述

为什么需要分布式锁

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

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

什么是分布式锁

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

分布式锁的特点

分布式锁问题_业务介绍

案列介绍

技术选型

创建表

创建订单表

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项目

引入依赖

   <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);
   }
}

测试订单

复习：

Single Thread Execution 设计模式

机场过安检

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

非线程安全

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

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 请求的时候，页面是异步的进行后台处理，用户无须一直等待请求的结果，可以继续浏览或操作其他内容。

Master-Worker 设计模式

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

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

生产者消费者设计模式

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

具体代码逻辑实现思路：

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();
    }
}

运行结果如下：

我们先自己来解决一下这个问题，线程不安全，我给它放到 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();
    }
}

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

定义不可变对象的策略

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

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

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 + '\'' + '}';
  }
}