本文详细介绍了如何使用Redis解决并发秒杀中的连接超时和超卖问题。通过引入连接池解决连接超时，利用乐观锁确保事务的原子性避免超卖。然而，仍存在库存遗留问题，最终通过LUA脚本实现类似悲观锁的效果，确保库存准确无误。在并发测试中，所有问题均得到有效解决。
Redis6
9.3.3）并发的秒杀案例实现
上一篇《Redis(10) -- 不考虑并发的秒杀案例实现》因没有考虑并发，而存在的连接超时问题和超卖问题解决方案如下：
9.3.3.1）连接超时，通过连接池解决
连接池：
-
节省每次连接redis服务带来的消耗，把连接好的实例反复利用；
-
通过参数管理连接的行为
连接池参数：
-
MaxTotal：控制一个pool可分配多少个jedis实例，通过pool.getResource()来获取；如果赋值为-1，则表示不限制；如果pool已经分配了MaxTotal个jedis实例，则此时pool的状态为exhausted；
-
maxIdle：控制一个pool最多有多少个状态为idle(空闲)的jedis实例；
-
MaxWaitMillis：表示当borrow一个jedis实例时，最大的等待毫秒数，如果超过等待时间，则直接抛JedisConnectionException；
-
testOnBorrow：获得一个jedis实例的时候是否检查连接可用性（ping()）；如果为true，则得到的jedis实例均是可用的；
Redis连接池配置类：JedisPoolUtil.java
public class JedisPoolUtil {
private static volatile JedisPool jedisPool = null;
private JedisPoolUtil() {
}
// 连接池资源连接方法
public static JedisPool getJedisPoolInstance() {
if (null == jedisPool) {
synchronized (JedisPoolUtil.class) {
if (null == jedisPool) {
JedisPoolConfig poolConfig = new JedisPoolConfig();
poolConfig.setMaxTotal(200);
poolConfig.setMaxIdle(32);
poolConfig.setMaxWaitMillis(100 * 1000);
poolConfig.setBlockWhenExhausted(true);
poolConfig.setTestOnBorrow(true); // ping PONG
jedisPool = new JedisPool(poolConfig, "127.0.0.1", 11079, 60000);
}
}
}
return jedisPool;
}
// 连接池资源释放方法
public static void release(JedisPool jedisPool, Jedis jedis) {
if (null != jedis) {
jedisPool.returnResource(jedis);
}
}
}修改上述 Redis接口实现类 SecKill_redis.java 中 连接redis的方法为通过连接池得到jedis对象
//步骤2 连接redis
// Jedis jedis = new Jedis("127.0.0.1", 11079);
// 步骤2 通过连接池得到jedis对象
JedisPool jedisPoolInstance = JedisPoolUtil.getJedisPoolInstance();
Jedis jedis = jedisPoolInstance.getResource();9.3.3.2）超卖问题
超卖问题：已经秒杀结束了，但还存在秒杀成功的情况；Redis 中的商品信息为 -3，不能出现商品为负数的情况
解决方案：利用乐观锁淘汰用户，解决超卖问题
修改上述 Redis接口实现类 SecKill_redis.java 中 秒杀的过程添加乐观锁事务管理
//秒杀主方法--全过程
public static boolean doSecKill(String uid, String prodid) throws IOException {
//步骤1 根据入参用户ID-uid和商品ID-prodid 进行非空判断
if (uid == null || prodid == null) {
return false;
}
//步骤2 连接redis
// Jedis jedis = new Jedis("127.0.0.1", 11079);
// 步骤2 通过连接池得到jedis对象
JedisPool jedisPoolInstance = JedisPoolUtil.getJedisPoolInstance();
Jedis jedis = jedisPoolInstance.getResource();
//步骤3 拼接key
// 3.1 库存key
String kcKey = "sk:" + prodid + ":qt";
// 3.2 秒杀成功的用户key
String userKey = "sk:" + prodid + ":user";
// 秒杀过程添加乐观锁事务管理 -- 监视库存
jedis.watch(kcKey);
// 步骤4 获取库存，如果库存null，秒杀还没有开始
String kc = jedis.get(kcKey);
if (kc == null) {
System.out.println("秒杀还没有开始，请等待");
jedis.close();
return false;
}
// 步骤5 判断用户是否重复秒杀操作
// 判断set集合中的用户信息，因为不能存在重复的用户【不能重复秒杀】所以使用Set存储用户信息
if (jedis.sismember(userKey, uid)) {
System.out.println("已经秒杀成功了，不能重复秒杀");
jedis.close();
return false;
}
// 步骤6 判断如果商品数量，库存数量小于1，秒杀结束
if (Integer.parseInt(kc) <= 0) {
System.out.println("秒杀已经结束了");
jedis.close();
return false;
}
/* // 步骤7 秒杀的过程
//7.1 库存-1
jedis.decr(kcKey);
//7.2 把秒杀成功用户添加清单里面
jedis.sadd(userKey, uid);*/
//步骤7改造 秒杀过程添加乐观锁事务管理
//使用事务
Transaction multi = jedis.multi();
//组队操作
multi.decr(kcKey);
multi.sadd(userKey,uid);
//执行
List<Object> results = multi.exec();
if(results == null || results.size()==0) {
System.out.println("秒杀失败了....");
jedis.close();
return false;
}
System.out.println("秒杀成功了..");
jedis.close();
return true;
}再次使用并发测试，通过ab进行测试，测试结果如下：
【超卖问题】和【连接池超时问题】均已解决
9.3.3.3）库存遗留问题
上述解决方案仍然存在一些问题，这次将库存商品设置为500
再次进行并发测试，通过ab进行测试，测试结果如下：
【2000个请求、300个并发，调用172.19.83.237（个人主机）上的秒杀方法】
发现此时秒杀已经结束，但库存商品还剩393个没有秒杀完，这是由于乐观锁事务管理造成的的库存遗留问题
【因为乐观锁，第一个成功的用户将版本号修改了，造成的版本不一致，即使商品还存在，但由于版本号不同了，所以即使有商品其余用户也不能继续购买了】
库存遗留问题解决方案：
理论上使用悲观锁就可以解决该问题，但Redis中默认不能直接使用悲观锁，所以此路不通
典型方案：使用LUA脚本语言解决
LUA脚本在Redis中的优势
将复杂的或者多步的redis操作，写为一个脚本，一次提交给redis执行，减少反复连接redis的次数。提升性能；
LUA脚本是类似redis事务，有一定的原子性，不会被其他命令插队，可以完成一些redis事务性的操作；
但是注意redis的lua脚本功能，只有在Redis 2.6以上的版本才可以使用；
利用lua脚本淘汰用户，解决超卖问题；
redis 2.6版本以后，通过lua脚本解决争抢问题，实际上是redis 利用其单线程的特性，用任务队列的方式解决多任务并发问题。
解决流程如下图：
新增Redis接口LUA脚本调用类 SecKill_redisByScript.java
public class SecKill_redisByScript {
private static final org.slf4j.Logger logger = LoggerFactory.getLogger(SecKill_redisByScript.class);
public static void main(String[] args) {
JedisPool jedispool = JedisPoolUtil.getJedisPoolInstance();
Jedis jedis = jedispool.getResource();
System.out.println(jedis.ping());
}
// return 2 ：已经秒杀过
// return 0 ：已经秒杀结束
// return 1 ：秒杀成功
static String secKillScript = "local userid=KEYS[1];\r\n" +
"local prodid=KEYS[2];\r\n" +
"local qtkey='sk:'..prodid..\":qt\";\r\n" +
"local usersKey='sk:'..prodid..\":usr\";\r\n" +
"local userExists=redis.call(\"sismember\",usersKey,userid);\r\n" +
"if tonumber(userExists)==1 then \r\n" +
" return 2;\r\n" +
"end\r\n" +
"local num= redis.call(\"get\" ,qtkey);\r\n" +
"if tonumber(num)<=0 then \r\n" +
" return 0;\r\n" +
"else \r\n" +
" redis.call(\"decr\",qtkey);\r\n" +
" redis.call(\"sadd\",usersKey,userid);\r\n" +
"end\r\n" +
"return 1";
public static boolean doSecKill(String uid, String prodid) throws IOException {
// 通过连接池得到jedis对象
JedisPool jedispool = JedisPoolUtil.getJedisPoolInstance();
Jedis jedis = jedispool.getResource();
// 加载LUA脚本 secKillScript
String sha1 = jedis.scriptLoad(secKillScript);
// 利用LUA脚本调用相关Redis操作方法
Object result = jedis.evalsha(sha1, 2, uid, prodid);
String reString = String.valueOf(result);
if ("0".equals(reString)) {
System.err.println("已抢空！！");
} else if ("1".equals(reString)) {
System.out.println("抢购成功！！！！");
} else if ("2".equals(reString)) {
System.err.println("该用户已抢过！！");
} else {
System.err.println("抢购异常！！");
}
jedis.close();
return true;
}
}修改在Redis接口类 SecKillServlet中调用秒杀的方法
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 通过随机数生成用户id
String userid = new Random().nextInt(50000) + "";
// 接收调用的商品id
String prodid = request.getParameter("prodid");
// 调用秒杀方法
// boolean isSuccess = SecKill_redis.doSecKill(userid, prodid);
// 调用LUA脚本中的秒杀方法
boolean isSuccess= SecKill_redisByScript.doSecKill(userid,prodid);
// 根据秒杀的返回结果返回相应信息
response.getWriter().print(isSuccess);
}测试输出：再次进行并发测试，通过ab进行测试，测试结果如下：
【2000个请求、300个并发，调用127.0.0.1（个人主机）上的秒杀方法】
库存最后经过秒杀后变成了 0 ，至此库存遗留问题解决。
扫一扫
3万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
