基于redis实现的扣减库存

左手的ㄟ右手 2022-05-19 05:45 260阅读 0赞

在日常开发中有很多地方都有类似扣减库存的操作，比如电商系统中的商品库存，抽奖系统中的奖品库存等。

# 解决方案 #

1.  使用mysql数据库，使用一个字段来存储库存，每次扣减库存去更新这个字段。
2.  还是使用数据库，但是将库存分层多份存到多条记录里面，扣减库存的时候路由一下，这样子增大了并发量，但是还是避免不了大量的去访问数据库来更新库存。
3.  将库存放到redis使用redis的incrby特性来扣减库存。

# 分析 #

在上面的第一种和第二种方式都是基于数据来扣减库存。

## 基于数据库单库存 ##

第一种方式在所有请求都会在这里等待锁，获取锁有去扣减库存。在并发量不高的情况下可以使用，但是一旦并发量大了就会有大量请求阻塞在这里，导致请求超时，进而整个系统雪崩；而且会频繁的去访问数据库，大量占用数据库资源，所以在并发高的情况下这种方式不适用。

## 基于数据库多库存 ##

第二种方式其实是第一种方式的优化版本，在一定程度上提高了并发量，但是在还是会大量的对数据库做更新操作大量占用数据库资源。

**基于数据库来实现扣减库存还存在的一些问题：**

*  用数据库扣减库存的方式，扣减库存的操作必须在一条语句中执行，不能先selec在update，这样在并发下会出现超扣的情况。如：

update number set x=x-1 where x > 0

理论上即使是这样由于MySQL事务的特性，这种方法只能降低超卖的数量，但是不可能完全避免超扣。因为数据库默认隔离级别是repeatable read，假如库存是5，有A、B两个请求分别创建了事务并且都没有提交，当A事务提交了，改了库存为4，但是因为是事务隔离级别是可重复读的，所有B看不到A事务改的库存。到时B看到的库存还是5，所以B修改库存为4，这样就出现了超扣问题。所以我们扣库存的时候需要将事务隔离级别设置成read commit才可以。（我自己测试没有出现这种情况）

*  MySQL自身对于高并发的处理性能就会出现问题，一般来说，MySQL的处理性能会随着并发thread上升而上升，但是到了一定的并发度之后会出现明显的拐点，之后一路下降，最终甚至会比单thread的性能还要差。
 *  当减库存和高并发碰到一起的时候，由于操作的库存数目在同一行，就会出现争抢InnoDB行锁的问题，导致出现互相等待甚至死锁，从而大大降低MySQL的处理性能，最终导致前端页面出现超时异常。

## 基于redis ##

针对上述问题的问题我们就有了第三种方案，将库存放到缓存，利用redis的incrby特性来扣减库存，解决了超扣和性能问题。但是一旦缓存丢失需要考虑恢复方案。比如抽奖系统扣奖品库存的时候，初始库存=总的库存数-已经发放的奖励数，但是如果是异步发奖，需要等到MQ消息消费完了才能重启redis初始化库存，否则也存在库存不一致的问题。

# 基于redis实现扣减库存的具体实现 #

*  我们使用redis的lua脚本来实现扣减库存
 *  由于是分布式环境下所以还需要一个[分布式锁][Link 1]来控制只能有一个服务去初始化库存
 *  需要提供一个回调函数，在初始化库存的时候去调用这个函数获取初始化库存

## 初始化库存回调函数(IStockCallback ) ##

1.  `/**`
2.  `* 获取库存回调`
3.  `* @author yuhao.wang`
4.  `*/`
5.  `public interface IStockCallback {`
6.  
7.  `/**`
8.  `* 获取库存`
9.  `* @return`
10. `*/`
11. `int getStock();`
12. `}`
13.

## 扣减库存服务（StockService） ##

1.  `package com.xiaolyuh.service;`
2.  
3.  `import com.xiaolyuh.lock.RedisLock;`
4.  `import org.slf4j.Logger;`
5.  `import org.slf4j.LoggerFactory;`
6.  `import org.springframework.beans.factory.annotation.Autowired;`
7.  `import org.springframework.dao.DataAccessException;`
8.  `import org.springframework.data.redis.connection.RedisConnection;`
9.  `import org.springframework.data.redis.core.RedisCallback;`
10. `import org.springframework.data.redis.core.RedisTemplate;`
11. `import org.springframework.stereotype.Service;`
12. `import redis.clients.jedis.Jedis;`
13. `import redis.clients.jedis.JedisCluster;`
14. 
15. `import java.util.ArrayList;`
16. `import java.util.List;`
17. `import java.util.concurrent.TimeUnit;`
18. 
19. `/**`
20. `* 扣库存`
21. `*`
22. `* @author yuhao.wang`
23. `*/`
24. `@Service`
25. `public class StockService {`
26. `Logger logger = LoggerFactory.getLogger(StockService.class);`
27. 
28. `/**`
29. `* 库存不足`
30. `*/`
31. `public static final int LOW_STOCK = 0;`
32. 
33. `/**`
34. `* 不限库存`
35. `*/`
36. `public static final long UNINITIALIZED_STOCK = -1L;`
37. 
38. `/**`
39. `* Redis 客户端`
40. `*/`
41. `@Autowired`
42. `private RedisTemplate<String, Object> redisTemplate;`
43. 
44. `/**`
45. `* 执行扣库存的脚本`
46. `*/`
47. `public static final String STOCK_LUA;`
48. 
49. `static {`
50. `/**`
51. `*`
52. `* @desc 扣减库存Lua脚本`
53. `* 库存（stock）-1：表示不限库存`
54. `* 库存（stock）0：表示没有库存`
55. `* 库存（stock）大于0：表示剩余库存`
56. `*`
57. `* @params 库存key`
58. `* @return`
59. `* 0:库存不足`
60. `* -1:库存未初始化`
61. `* 大于0:剩余库存（扣减之前剩余的库存）`
62. `* redis缓存的库存(value)是-1表示不限库存，直接返回1`
63. `*/`
64. `StringBuilder sb = new StringBuilder();`
65. `sb.append("if (redis.call('exists', KEYS[1]) == 1) then");`
66. `sb.append(" local stock = tonumber(redis.call('get', KEYS[1]));");`
67. `sb.append(" if (stock == -1) then");`
68. `sb.append(" return 1;");`
69. `sb.append(" end;");`
70. `sb.append(" if (stock > 0) then");`
71. `sb.append(" redis.call('incrby', KEYS[1], -1);");`
72. `sb.append(" return stock;");`
73. `sb.append(" end;");`
74. `sb.append(" return 0;");`
75. `sb.append("end;");`
76. `sb.append("return -1;");`
77. `STOCK_LUA = sb.toString();`
78. `}`
79. 
80. `/**`
81. `* @param key 库存key`
82. `* @param expire 库存有效时间,单位秒`
83. `* @param stockCallback 初始化库存回调函数`
84. `* @return 0:库存不足; -1:库存未初始化; 大于0:扣减库存之前的剩余库存（扣减之前剩余的库存）`
85. `*/`
86. `public long stock(String key, long expire, IStockCallback stockCallback) {`
87. `long stock = stock(key);`
88. `// 初始化库存`
89. `if (stock == UNINITIALIZED_STOCK) {`
90. `RedisLock redisLock = new RedisLock(redisTemplate, key);`
91. `try {`
92. `// 获取锁`
93. `if (redisLock.tryLock()) {`
94. `// 双重验证，避免并发时重复回源到数据库`
95. `stock = stock(key);`
96. `if (stock == UNINITIALIZED_STOCK) {`
97. `// 获取初始化库存`
98. `final int initStock = stockCallback.getStock();`
99. `// 将库存设置到redis`
100. `redisTemplate.opsForValue().set(key, initStock, expire, TimeUnit.SECONDS);`
101. `// 调一次扣库存的操作`
102. `stock = stock(key);`
103. `}`
104. `}`
105. `} catch (Exception e) {`
106. `logger.error(e.getMessage(), e);`
107. `} finally {`
108. `redisLock.unlock();`
109. `}`
110. 
111. `}`
112. `return stock;`
113. `}`
114. 
115. `/**`
116. `* 获取库存`
117. `*`
118. `* @param key 库存key`
119. `* @return 0:库存不足; -1:库存未初始化; 大于0:剩余库存`
120. `*/`
121. `public int getStock(String key) {`
122. `Integer stock = (Integer) redisTemplate.opsForValue().get(key);`
123. `return stock == null ? -1 : stock;`
124. `}`
125. 
126. `/**`
127. `* 扣库存`
128. `*`
129. `* @param key 库存key`
130. `* @return 扣减之前剩余的库存【0:库存不足; -1:库存未初始化; 大于0:扣减库存之前的剩余库存】`
131. `*/`
132. `private Long stock(String key) {`
133. `// 脚本里的KEYS参数`
134. `List<String> keys = new ArrayList<>();`
135. `keys.add(key);`
136. `// 脚本里的ARGV参数`
137. `List<String> args = new ArrayList<>();`
138. 
139. `long result = redisTemplate.execute(new RedisCallback<Long>() {`
140. `@Override`
141. `public Long doInRedis(RedisConnection connection) throws DataAccessException {`
142. `Object nativeConnection = connection.getNativeConnection();`
143. `// 集群模式和单机模式虽然执行脚本的方法一样，但是没有共同的接口，所以只能分开执行`
144. `// 集群模式`
145. `if (nativeConnection instanceof JedisCluster) {`
146. `return (Long) ((JedisCluster) nativeConnection).eval(STOCK_LUA, keys, args);`
147. `}`
148. 
149. `// 单机模式`
150. `else if (nativeConnection instanceof Jedis) {`
151. `return (Long) ((Jedis) nativeConnection).eval(STOCK_LUA, keys, args);`
152. `}`
153. `return UNINITIALIZED_STOCK;`
154. `}`
155. `});`
156. `return result;`
157. `}`
158. 
159. `}`
160.

## 调用 ##

1.  `/**`
2.  `* @author yuhao.wang`
3.  `*/`
4.  `@RestController`
5.  `public class StockController {`
6.  
7.  `@Autowired`
8.  `private StockService stockService;`
9.  
10. `@RequestMapping(value = "stock", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)`
11. `public Object stock() {`
12. `// 商品ID`
13. `long commodityId = 1;`
14. `// 库存ID`
15. `String redisKey = "redis_key:stock:" + commodityId;`
16. `long stock = stockService.stock(redisKey, 60 * 60, () -> initStock(commodityId));`
17. `return stock > 0;`
18. `}`
19. 
20. `/**`
21. `* 获取初始的库存`
22. `* @return`
23. `*/`
24. `private int initStock(long commodityId) {`
25. `// TODO 这里做一些初始化库存的操作`
26. `return 1000;`
27. `}`
28. 
29. `@RequestMapping(value = "getStock", produces = MediaType.APPLICATION_JSON_UTF8_VALUE)`
30. `public Object getStock() {`
31. `// 商品ID`
32. `long commodityId = 1;`
33. `// 库存ID`
34. `String redisKey = "redis_key:stock:" + commodityId;`
35. 
36. `return stockService.getStock(redisKey);`
37. `}`
38. `}`
39.

源码： [https://github.com/wyh-spring-ecosystem-student/spring-boot-student/tree/releases][https_github.com_wyh-spring-ecosystem-student_spring-boot-student_tree_releases]

spring-boot-student-stock-redis 工程

[Link 1]: https://www.jianshu.com/p/8cc44d008177
[https_github.com_wyh-spring-ecosystem-student_spring-boot-student_tree_releases]: https://link.jianshu.com/?t=https%3A%2F%2Fgithub.com%2Fwyh-spring-ecosystem-student%2Fspring-boot-student%2Ftree%2Freleases