使用redis分布式锁高并发下QPS测试，单机一秒下1千个订单

迷南。 2023-06-08 03:06 15阅读 0赞

[前面一篇][Link 1]讲过并发下单时进行优化的一些策略，后来我写了代码进行了实测。

关于redisson做分布式锁的代码在[这篇文章][Link 2]。这里我来测试一下分布式锁的性能。

简单的controller

package com.tianyalei.redislock.controller;
    
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import javax.annotation.Resource;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * @author wuweifeng wrote on 2019-10-15.
     */
    @RequestMapping("/redisLock")
    @RestController
    public class IndexController {
        @Resource
        private IndexService indexService;
    
        private volatile AtomicInteger index = new AtomicInteger(Integer.MAX_VALUE);
    
    
        @RequestMapping("random")
        public String sellTwo(int count) {
            int i = index.getAndDecrement() % count;
            if (i == 0) {
                indexService.sell(0);
            } else if (i == 1) {
                indexService.sell(1);
            } else if (i == 2) {
                indexService.sell(2);
            } else if (i == 3) {
                indexService.sell(3);
            } else if (i == 4) {
                indexService.sell(4);
            }
    
            return "ok";
        }
    
        @RequestMapping("mm")
        public String sellmm(int count) {
            int i = index.getAndDecrement() % count;
            if (i == 0) {
                indexService.sellMemory(0);
            } else if (i == 1) {
                indexService.sellMemory(1);
            } else if (i == 2) {
                indexService.sellMemory(2);
            } else if (i == 3) {
                indexService.sellMemory(3);
            } else if (i == 4) {
                indexService.sellMemory(4);
            }
    
            return "ok";
        }
    }

定义了2个接口，上面的是用redis分布式锁，下面的是走内存。

package com.tianyalei.redislock.controller;
    
    import com.tianyalei.redislock.annotation.RedissonLock;
    import org.slf4j.Logger;
    import org.slf4j.LoggerFactory;
    import org.springframework.data.redis.core.StringRedisTemplate;
    import org.springframework.stereotype.Service;
    
    import javax.annotation.Resource;
    import java.util.Random;
    import java.util.concurrent.atomic.AtomicInteger;
    
    /**
     * @author wuweifeng wrote on 2019-10-15.
     */
    @Service
    public class IndexService {
        @Resource
        private StringRedisTemplate stringRedisTemplate;
        private Logger logger = LoggerFactory.getLogger(getClass());
    
        private volatile AtomicInteger count1 = new AtomicInteger(500000);
        private volatile AtomicInteger count2 = new AtomicInteger(500000);
        private volatile AtomicInteger count3 = new AtomicInteger(500000);
        private volatile AtomicInteger count4 = new AtomicInteger(500000);
        private volatile AtomicInteger count5 = new AtomicInteger(500000);
    
    
        /**
         * 上分布式锁
         */
        @RedissonLock(lockIndex = 0)
        public void sell(Integer goodsId) {
            logger.info("goodId：" + goodsId);
            stringRedisTemplate.opsForValue().set(getRandomString(8), System.currentTimeMillis() + "abc");
            logger.info(System.currentTimeMillis() + "");
        }
    
        /**
         * 直接读内存
         */
        public void sellMemory(Integer goodsId) {
            logger.info("goodId：" + goodsId);
            switch (goodsId) {
                case 0:
                    logger.info("count1：" + count1.getAndDecrement());
                    break;
                case 2:
                    logger.info("count2：" + count2.getAndDecrement());
                    break;
                case 3:
                    logger.info("count3：" + count3.getAndDecrement());
                    break;
                case 4:
                    logger.info("count4：" + count4.getAndDecrement());
                    break;
                default:
                    logger.info("count5：" + count5.getAndDecrement());
                    break;
            }
    
            stringRedisTemplate.opsForValue().set(getRandomString(8), System.currentTimeMillis() + "abc");
            logger.info(System.currentTimeMillis() + "");
        }
    
        public static String getRandomString(int length) {
            String str = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
            Random random = new Random();
            StringBuffer sb = new StringBuffer();
            for (int i = 0; i < length; i++) {
                int number = random.nextInt(62);
                sb.append(str.charAt(number));
            }
            return sb.toString();
        }
    }

关于RedissonLock注解在前面的文章里写了代码了。

sell方法就是针对goodsId进行加分布式锁，如果只有一个商品的话，就等于是完全在该商品的售卖上进行排队，性能就全靠redis的加锁解锁和业务耗时了。业务方面我采用直接将订单下到redis里的方式，不走数据库。正常情况下，业务耗时在10ms左右比较靠谱。

sellMemory方法就是完全在内存中进行商品数量的减少，摆脱掉redis的网络通信。业务上也是将订单下到redis中。

redis的一次加锁、解锁，我们可以计算它的耗时，加锁是一次通信，加锁失败后排队，然后等待redis的Channel监听回调，回调这又是一次通信，回调后再次去试图加锁并成功，这又是一次通信，业务上在redis里下一单，这又是一次通信。共计4次。

那么在业务耗时相同的情况下，在内存中直接扣减库存会比通过redis分布式锁，少4次网络IO。

结果如下：

通过redis分布式锁下单

200个线程并发，循环1次，购买1个商品，锁在同一个goodsId。共计600ms，200单下单完毕。

200个线程并发，循环2次，购买1个商品，锁在同一个goodsId。共计1100ms，400单下单完毕。

200个线程并发，循环2次，购买5个商品，锁在不同的goodsId，性能明显有所提升。共计600ms，400单下单完毕。

400个线程并发，循环1次，购买5个商品，锁在不同的goodsId。共计600ms，400单下单完毕。

400个线程并发，循环2次，购买5个商品，锁在不同的goodsId。共计1000ms，800单下单完毕。