java 用redis如何处理电商平台，秒杀、抢购超卖

一、刚来公司时间不长，看到公司原来的同事写了这样一段代码，下面贴出来：

1、这是在一个方法调用下面代码的部分：

[java]  view plain  copy

1. if (!this.checkSoldCountByRedisDate(key, limitCount, buyCount, endDate)) {// 标注10：  
2.                 throw new ServiceException("您购买的商品【" + commodityTitle + "】,数量已达到活动限购量");  
3.             }  

2、下面是判断超卖的方法：

[java]  view plain  copy

1. /** 根据缓存数据查询是否卖超 */  
2.     //标注：1；synchronized   
3.     private synchronized boolean checkSoldCountByRedisDate(String key, int limitCount, int buyCount, Date endDate) {  
4.         boolean flag = false;  
5.         if (redisUtil.exists(key)) {//标注:2;redisUtil.exists(key)  
6.             Integer soldCount = (int) redisUtil.get(key);//标注：3；redisUtil.get(key)  
7.             Integer totalSoldCount = soldCount + buyCount;  
8.             if (limitCount > (totalSoldCount)) {  
9.                 flag = false;//标注：4；flag = false  
10.             } else {  
11.                 if (redisUtil.tryLock(key, 80)) {//标注：5；rdisUtil.tryLock(key, 80)  
12.   
13.                     redisUtil.remove(key);// 解锁 //标注：6；redisUtil.remove(key)  
14.   
15.                     redisUtil.set(key, totalSoldCount);//标注：7；redisUtil.set(key, totalSoldCount)  
16.   
17.                     flag = true;  
18.                 } else {  
19.                     throw new ServiceException("活动太火爆啦,请稍后重试");  
20.                 }  
21.             }  
22.         } else {  
23.             //标注:8;redisUtil.set(key, new String("buyCount"), DateUtil.diffDateTime(endDate, new Date()))  
24.             redisUtil.set(key, new String("buyCount"), DateUtil.diffDateTime(endDate, new Date()));  
25.             flag = false;  
26.         }  
27.         return flag;  
28.     }  

3、上面提到的redisUtil类中的方法，其中redisTemplate为org.springframework.data.redis.core.RedisTemplate;这个不了解的可以去网上找下，spring-data-redis.jar的相关文档，贴出来redisUtil用到的相关方法：

[java]  view plain  copy

1. /** 
2.      * 判断缓存中是否有对应的value 
3.      *  
4.      * @param key 
5.      * @return 
6.      */  
7.     public boolean exists(final String key) {  
8.         return redisTemplate.hasKey(key);  
9.     }  
10.     /** 
11.      * 将键值对设定一个指定的时间timeout. 
12.      *  
13.      * @param key 
14.      * @param timeout 
15.      *            键值对缓存的时间，单位是毫秒 
16.      * @return 设置成功返回true，否则返回false 
17.      */  
18.     public boolean tryLock(String key, long timeout) {  
19.         boolean isSuccess = redisTemplate.opsForValue().setIfAbsent(key, "");  
20.         if (isSuccess) {//标注：9；redisTemplate.expire  
21.   
22.             redisTemplate.expire(key, timeout, TimeUnit.MILLISECONDS);  
23.         }  
24.         return isSuccess;  
25.     }  
26.     /** 
27.      * 读取缓存 
28.      *  
29.      * @param key 
30.      * @return 
31.      */  
32.     public Object get(final String key) {  
33.         Object result = null;  
34.         ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();  
35.         result = operations.get(key);  
36.         return result;  
37.     }  
38.     /** 
39.      * 删除对应的value 
40.      *  
41.      * @param key 
42.      */  
43.     public void remove(final String key) {  
44.         if (exists(key)) {  
45.             redisTemplate.delete(key);  
46.         }  
47.     }  
48.     /** 
49.      * 写入缓存 
50.      *  
51.      * @param key 
52.      * @param value 
53.      * @return 
54.      */  
55.     public boolean set(final String key, Object value) {  
56.         return set(key, value, null);  
57.     }  
58.     /** 
59.      *  
60.      * @Title: set 
61.      * @Description: 写入缓存带有效期 
62.      * @param key 
63.      * @param value 
64.      * @param expireTime 
65.      * @return boolean    返回类型 
66.      * @throws 
67.      */  
68.     public boolean set(final String key, Object value, Long expireTime) {  
69.         boolean result = false;  
70.         try {  
71.             ValueOperations<Serializable, Object> operations = redisTemplate.opsForValue();  
72.             operations.set(key, value);  
73.             if (expireTime != null) {  
74.                 redisTemplate.expire(key, expireTime, TimeUnit.SECONDS);  
75.             }  
76.             result = true;  
77.         } catch (Exception e) {  
78.             e.printStackTrace();  
79.         }  
80.         return result;  
81.     }  

4、上面提到的DateUtil类，我会在下面用文件的形式发出来！

二、现在我们来解读下这段代码，看看作者的意图，以及问题点在什么地方，这样帮助更多的人了解，在电商平台如何处理在抢购、秒杀时出现的超卖的情况处理

1、参数说明，上面checkSoldCountByRedisDate方法，有4个参数分别是：

 key：购买数量的计数，放于Redis缓存中的key；

 limitCount：查找源码发现，原注释为：总限购数量；

 buyCount：为当前一次请求下单要购买的数量；

 endDate：活动结束时间；

2、通过上面的标注，我们来解析原作者的意图：

标注1：想通过synchronized关键字实现同步，看似没问题

标注2：通过redisUtil.exists方法判断key是否存在，看似没什么问题

标注3：redisUtil.get(key)获取购买总数，似乎也没问题

标注4：当用户总购买数量<总限购量返回false，看起来只是一个简单的判断

标注5:想通过redisUtil.tryLock加锁，实现超卖的处理，后面的代码实现计数，好像也没什么问题
标注6：标注5加了锁，那么通过redisUtil.remove解锁，看起来顺理成章

标注7：通过redisUtil.set来记录用户购买量，原作者应该是这个意思了

标注8：如果标注2判断的key不存在，在这里创建一个key，看起来代码好像也是要这么写

标注9：我想原作者是不想出现死锁，用redisTemplate.expire做锁超时的方式来解除死锁，这样是可以的

3、针对上面作者意图的分析，我们来看下，看似没有问题的，是否真的就是没问题！呵呵。。，好贱！

下面看看每个标注，可能会出现的问题：

标注1：synchronized关键字，在分布式高并发的情况下，不能实现同步处理，不信测试下就知道了；

那么就可能会出现 的问题是：

现在同一用户发起请A、B或不同用户发起请求A、B，会同时进入checkSoldCountByRedisDate方法并执行

标注2：当抢购开始时，A、B请求同时率先抢购，进入checkSoldCountByRedisDate方法，

A、B请求被redisUtil.exists方法判断key不存在，

从而执行了标注8的部分，同时去执行一个创建key的动作；

真的是好坑啊！第一个开始抢购都抢不到！

标注3：当请求A、B同时到达时，假设：请求A、B当前购买buyCount参数为40，标注3得到的soldCount=50，limitCount=100，

此时请求A、B得到的totalSoldCount均为90，问题又来了

标注4：limitCount > (totalSoldCount)：totalSoldCount=90，limitCount=100，些时flag就等于 false，

返回给标注10的位置抛出异常信息（throw new ServiceException("您购买的商品【" + commodityTitle + "】,数量已达到活动限购量");）；

请求A、B都没抢到商品。什么鬼？总共购买90，总限购量是100，这就抛出异常达到活动限购数，我开始看不懂了

标注5：在这里加锁的时候，如果当执行到标注9：isSuccess=true,客户端中断，不执行标注9以后的代码，

完蛋，死锁出现了！谁都别想抢到

下面我们假设A请求比B请求稍慢一点儿到达时，A、B请求的buyCount参数为40，标注3得到的soldCount=50、limitCount=100去执行的else里面的代码，

也就checkSoldCountByRedisDate方法中的：

[java]  view plain  copy

1. else {  
2.                 if (redisUtil.tryLock(key, 80)) {  
3.   
4.                     redisUtil.remove(key);// 解锁  
5.   
6.                     redisUtil.set(key, totalSoldCount);  
7. <span style="margin: 0px; padding: