前言
在通过多线程来解决高并发的问题上，线程安全往往是最先需要考虑的问题，其次才是性能。库存超卖问题是有很多种技术解决方案的，比如悲观锁，分布式锁，乐观锁，队列串行化，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进行并发测试。由于不是此处的重点，不再做演示，感兴趣的小伙伴可以留言，我会整理下相关的教程。
后续
这篇文章通过数据库乐观锁已经解决了库存超卖的问题，不过效率上并不是最优方案，后续会完善其他方案的演示。文中如有错漏之处，还望大家不吝赐教。
公众号 【当我遇上你】
