最简单有效的秒杀限流

整点秒杀、限时特卖等活动会吸引大量用户在同一时间点、时间段访问请求系统,从而产生大的并发量,如果没有合理处理的话会出现商品超卖页面访问速度较慢更严重的可能出现系统宕机其他服务也无法正常使用。

本文主要处理服务端使用redis进行限流

涉及到的技术点主要有:

redis分布式锁 redis常用命令

主要逻辑方案:

  1. 预热库存数据

  2. 限流(允许进入两倍库存的访问量)

  3. 10秒失效一次redis库存数据 重新获取(处理因为进入下单页没有提交订单 而导致的库存剩余)

实现

  1. 主要实现代码 判断是否有库存isEnoughRepository

    /**
     * @author lemon
     * @date 2018-10-06
     * @desc jedis实现秒杀限流
     */
    @Component
    public class JedisSecKill {
    
        public static final Log LWT_LOG = LogFactory.getLog(JedisSecKill.class.getName());
    
        @Resource
        MallProductDao mallProductDao;
    
        /**
         * 初始化商品的库存
         * 1. 如果已经初始化则不需要初始化 直接返回true
         * 2. 获取jedis分布式 获取成功查询库 更新jedis库存(如果库存为0则标记已售完)
         * 3. 库存信息10秒后失效
         * @param productId
         * @return 是否初始化成功(之前初始化过/获取锁成功)
         */
        private boolean initRepository(final int productId) {
            final String secProductKey = String.format(JedisKeyConstant.SEC_KILL_PRODUCT, productId + "");
            if (JedisUtil.exists(secProductKey)) {
                return true;
            }
    
            final String secProductStatusKey = String.format(JedisKeyConstant.SEC_KILL_PRODUCT_STATUS, productId + "");
            boolean lock = JedisLock.lock(productId + "", new LockFunction() {
                @Override
                public void call() {
                    List<MallProductSpec> productSpecs = mallProductDao.listMallProductSpec(productId);
                    if (CollectionUtils.isNotEmpty(productSpecs)) {
                        boolean isSoldOut = true;
                        for (MallProductSpec spec : productSpecs) {
                            if (StringUtils.equals(spec.getUseRepository(), "N")) {
                                isSoldOut = false;
                                break;
                            }
    
                            if (StringUtils.equals(spec.getUseRepository(), "Y") && spec.getRepository() > 0) {
                                isSoldOut = false;
                                break;
                            }
    
                        }
    
                        if (isSoldOut) {
                            JedisUtil.set(secProductStatusKey, "soldOut");
                            JedisUtil.expire(secProductStatusKey, 60);
                            return;
                        } else {
                            JedisUtil.set(secProductStatusKey, "inSale", "NX", "EX", 60);
                        }
    
                        initPerRepository(productSpecs);
                    }
                }
    
                private void initPerRepository(List<MallProductSpec> productSpecs) {
                    Jedis jedis = null;
                    try {
                        jedis = JedisUtil.getJedis();
                        String setRes = jedis.set(secProductKey, "inSale", "NX", "EX", 10);
                        if (StringUtils.equals("OK", setRes)) {
                            for (MallProductSpec spec : productSpecs) {
                                String specKey = String.format(JedisKeyConstant.SEC_KILL_PRODUCT_SPEC, spec.getSpecKey());
                                if (StringUtils.equals(spec.getUseRepository(), "N")) {
                                    jedis.set(specKey, 99 + "", "NX", "EX", 10);
                                } else {
                                    jedis.set(specKey, (spec.getRepository() * 2) + "", "NX", "EX", 10);
                                }
                            }
                        }
    
                    } catch (Exception e) {
                        e.printStackTrace();
                    } finally {
                        if (jedis != null) {
                            jedis.close();
                        }
                    }
                }
            });
            return lock;
        }
    
        /**
         * 根据商品id和规格 获取jedis是否有足够库存
         * 核心使用 jedis.decr 进行单线程操作库存 处理并发
         * @param productId
         * @param specKey
         * @return
         */
        public boolean isEnoughRepository(int productId, String specKey) {
            boolean initRes = initRepository(productId);
            if (!initRes) {
                return false;
            }
    
            final String secProductStatusKey = String.format(JedisKeyConstant.SEC_KILL_PRODUCT_STATUS, productId + "");
            Jedis jedis = null;
            try {
                jedis = JedisUtil.getJedis();
                String secStatus = jedis.get(secProductStatusKey);
                if (StringUtils.equals("soldOut", secStatus)) {
                    return false;
                }
    
                String specParamKey = String.format(JedisKeyConstant.SEC_KILL_PRODUCT_SPEC, specKey);
                Boolean exists = jedis.exists(specParamKey);
                Long decr = jedis.decr(specParamKey);
                LWT_LOG.debug("enoughRepository key:"+ specParamKey+" exists:" + exists + ",value:" + jedis.get(specParamKey) + ",decrValue:" + decr);
                if (exists && decr >= 0) {
                    return true;
                }
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
    
            return false;
        }
    
    }
    

  2. 其中常量值

    //秒杀使用此key控制库存是否过期
    public final static String SEC_KILL_PRODUCT = "sec_kill_product_%s";    
    //使用此key控制秒杀是否售罄
    public final static String SEC_KILL_PRODUCT_STATUS = "sec_kill_product_status_%s";
    //使用此key控制秒杀商品sku
    public final static String SEC_KILL_PRODUCT_SPEC = "sec_kill_product_spec_%s";
    

  3. redis分布式锁

    /**
     * @author lemon(lemon @ laowantong.cc)
     * @date 2018-10-06
     * @desc jedis 分布式锁
     */
    
    public class JedisLock {
    
        /**
         * 通过获取key的setnx
         * 如果获取成功 执行获取成功之后的function
         * 执行完成之后删除key释放锁
         * @param key
         * @param function
         * @return
         */
        public static boolean lock(String key, LockFunction function) {
            Jedis jedis = null;
            try {
                jedis = JedisUtil.getJedis();
                if (jedis != null) {
                    String setRes = jedis.set(key, "b", "NX", "EX", 5);
                    if (StringUtils.equals("OK", setRes)) {
                        function.call();
                        jedis.del(key);
                        return true;
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            } finally {
                if (jedis != null) {
                    jedis.close();
                }
            }
    
            return false;
        }
    }
    

此方案的问题

  1. 分布式锁竞争期间 其他争夺资源的并发请求 处理结果为失败
  2. 没有彻底满足先到先得的原则(可使用队列方案实现)

附一秒杀架构图 最简单有效的秒杀限流

欢迎交流 原文地址:

未经作者允许 请勿转载,谢谢 :)

原文 

https://seemoonup.github.io/2018/10/09/tech/电商/秒杀限流/

本站部分文章源于互联网,本着传播知识、有益学习和研究的目的进行的转载,为网友免费提供。如有著作权人或出版方提出异议,本站将立即删除。如果您对文章转载有任何疑问请告之我们,以便我们及时纠正。

PS:推荐一个微信公众号: askHarries 或者qq群:474807195,里面会分享一些资深架构师录制的视频录像:有Spring,MyBatis,Netty源码分析,高并发、高性能、分布式、微服务架构的原理,JVM性能优化这些成为架构师必备的知识体系。还能领取免费的学习资源,目前受益良多

转载请注明原文出处:Harries Blog™ » 最简单有效的秒杀限流

赞 (0)
分享到:更多 ()

评论 0

  • 昵称 (必填)
  • 邮箱 (必填)
  • 网址