经过乐观锁解决库存超卖的问题

前言

在经过多线程来解决高并发的问题上，线程安全每每是最早须要考虑的问题，其次才是性能。库存超卖问题是有不少种技术解决方案的，好比悲观锁，分布式锁，乐观锁，队列串行化，Redis原子操做等。本篇经过MySQL乐观锁来演示基本实现。

开发前准备

1. 环境参数

• 开发工具：IDEA
• 基础工具：Maven+JDK8
• 所用技术：SpringBoot+Mybatis
• 数据库：MySQL5.7
• SpringBoot版本：2.2.5.RELEASE

2. 建立数据库

基本的scheme已建好，演示就拿最简单的数据结构最好不过了。

DROP TABLE IF EXISTS `goods`;
CREATE TABLE `goods` (
  `id` int(11) NOT NULL AUTO_INCREMENT COMMENT '商品id',
  `name` varchar(30) DEFAULT NULL COMMENT '商品名称',
  `stock` int(11) DEFAULT '0' COMMENT '商品库存',
  `version` int(11) DEFAULT '0' COMMENT '并发版本控制',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT '商品表';

INSERT INTO `goods` VALUES (1, 'iphone', 10, 0);
INSERT INTO `goods` VALUES (2, 'huawei', 10, 0);

DROP TABLE IF EXISTS `order`;
CREATE TABLE `order` (
  `id` int(11) AUTO_INCREMENT,
  `uid` int(11) COMMENT '用户id',
  `gid` int(11) COMMENT '商品id',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT '订单表';
复制代码

没有环境的小伙伴能够经过Docker实战之MySQL主从复制，快速的进行MySQL环境的搭建。建立数据库test,而后导入相关的sql初始化Table。

3. 配置 pom 文件中的相关依赖

下边是pom.xml依赖配置。

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>2.1.1</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-devtools</artifactId>
            <scope>runtime</scope>
            <optional>true</optional>
        </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>
        </dependency>
复制代码

4. 配置 application.yml

因为演示中MyBatis基于接口映射，配置简单。application.yml中只须要配置mysql相关便可

spring:
 datasource:
 type: com.zaxxer.hikari.HikariDataSource
 driverClassName: com.mysql.cj.jdbc.Driver
 url: jdbc:mysql://localhost:3307/test?allowMultiQueries=true&useUnicode=true&characterEncoding=UTF-8&useSSL=false&serverTimezone=UTC
 username: root
 password: root
复制代码

5. 建立相关Bean

package com.idcmind.ants.entity;

public class Goods {

    private int id;
    private String name;
    private int stock;
    private int version;
    ...
    此处省略getter、setter以及 toString方法
}
复制代码

public class Order {

    private int id;
    private int uid;
    private int gid;
    ...
    此处省略getter、setter以及 toString方法
}
复制代码

乐观锁解决库存超卖方案

1. Dao层开发

GoodsDao.java

@Mapper
public interface GoodsDao {

    /** * 查询商品库存 * @param id 商品id * @return */
    @Select("SELECT * FROM goods WHERE id = #{id}")
    Goods getStock(@Param("id") int id);

    /** * 乐观锁方案扣减库存 * @param id 商品id * @param version 版本号 * @return */
    @Update("UPDATE goods SET stock = stock - 1, version = version + 1 WHERE id = #{id} AND stock > 0 AND version = #{version}")
    int decreaseStockForVersion(@Param("id") int id, @Param("version") int version);
}
复制代码

OrderDao.java

这里须要特别注意，因为order是sql中的关键字，因此表名须要加上反引号。

@Mapper
public interface OrderDao {
    
    /** * 插入订单 * 注意: order表是关键字，须要`order` * @param order */
    @Insert("INSERT INTO `order` (uid, gid) VALUES (#{uid}, #{gid})")
    @Options(useGeneratedKeys = true, keyProperty = "id")
    int insertOrder(Order order);
}
复制代码

2. Service层开发

GoodsService.java

@Service
public class GoodsService {

    @Autowired
    private GoodsDao goodsDao;
    @Autowired
    private OrderDao orderDao;

    /** * 扣减库存 * @param gid 商品id * @param uid 用户id * @return SUCCESS 1 FAILURE 0 */
    @Transactional
    public int sellGoods(int gid, int uid) {

        // 获取库存
        Goods goods = goodsDao.getStock(gid);
        if (goods.getStock() > 0) {
            // 乐观锁更新库存
            int update = goodsDao.decreaseStockForVersion(gid, goods.getVersion());
            // 更新失败，说明其余线程已经修改过数据，本次扣减库存失败，能够重试必定次数或者返回
            if (update == 0) {
                return 0;
            }
            // 库存扣减成功，生成订单
            Order order = new Order();
            order.setUid(uid);
            order.setGid(gid);
            int result = orderDao.insertOrder(order);
            return result;
        }
        // 失败返回
        return 0;
    }
}
复制代码

并发测试

这里咱们写个单元测试进行并发测试。

@SpringBootTest
class GoodsServiceTest {

    @Autowired
    GoodsService goodsService;

    @Test
    void seckill() throws InterruptedException {

        // 库存初始化为10，这里经过CountDownLatch和线程池模拟100个并发
        int threadTotal = 100;

        ExecutorService executorService = Executors.newCachedThreadPool();

        final CountDownLatch countDownLatch = new CountDownLatch(threadTotal);
        for (int i = 0; i < threadTotal ; i++) {
            int uid = i;
            executorService.execute(() -> {
                try {
                    goodsService.sellGoods(1, uid);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                countDownLatch.countDown();
            });
        }
        
        countDownLatch.await();
        executorService.shutdown();

    }
}
复制代码

查看数据库验证是否超卖

上图的结果与咱们的预期一致。此外还能够经过Postman或者Jmeter进行并发测试。因为不是此处的重点，再也不作演示，感兴趣的小伙伴能够留言，我会整理下相关的教程。

后续

这篇文章经过数据库乐观锁已经解决了库存超卖的问题，不过效率上并非最优方案，后续会完善其余方案的演示。文中若有错漏之处，还望你们不吝赐教。

公众号 【当我赶上你】