spring boot redis 商品秒杀设计

商品秒杀多数发生在高并发的时候，本文利用redis单线程原子性解决并发，减库存；

思路方案：

1. 模拟100个用户下单抢10个商品；

2.使用redis加锁，来实现减去库存；

3.其他用户一直等待，直到解锁后后面用户再加锁减库存，依次操作，直到库存为0；

4.用户等待，设置一下超时时间，防止一直等待下去；

5.判断库存是否小于等于0；

其中超时代码中有不要使用System.currentTimeMillis，高并发下性能很差，解决方案写了一个定时任务，1毫米间隔定时执行，然后去获取，代码SystemTimeUtil.now；

1.自定义SystemTimeUtil类，实现获取当前时间戳

package shop.seckill.example.utils;

import org.apache.commons.lang3.time.DateFormatUtils;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicLong;

/**
 * @author IT006448
 * @date 2022/01/17
 */
public class SystemTimeUtil {
    private final int period;

    private final AtomicLong now;

    private static class InstanceHolder {
        private static final SystemTimeUtil INSTANCE = new SystemTimeUtil(1);
    }

    //定时任务设置1毫秒
    private SystemTimeUtil(int period) {
        this.period = period;
        this.now = new AtomicLong(System.currentTimeMillis());
        scheduleClockUpdating();
    }

    private static SystemTimeUtil instance() {
        return InstanceHolder.INSTANCE;
    }

    private void scheduleClockUpdating() {
        //周期执行线程池
        ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor(runnable -> {
            Thread thread = new Thread(runnable, "System Clock");
            //守护线程
            thread.setDaemon(true);
            return thread;
        });
        //任务，开始时间，间隔时间=周期执行，时间单位
        scheduler.scheduleAtFixedRate(() -> now.set(System.currentTimeMillis()), 0, period, TimeUnit.MILLISECONDS);
    }

    private long currentTimeMillis() {
        return now.get();
    }

    /**
     * 用来替换原来的System.currentTimeMillis()
     */
    public static long now() {
        return instance().currentTimeMillis();
    }

    public static String nowTime() {
        long now = now();
        return DateFormatUtils.format(now, "yyyy-MM-dd hh:mm:ss");
    }

    public static void main(String[] args) throws InterruptedException {
        String now = SystemTimeUtil.nowTime();
        System.out.println(now);
        Thread.sleep(1000);
        now = SystemTimeUtil.nowTime();
        System.out.println(now);
        Thread.sleep(2000);
        now = SystemTimeUtil.nowTime();
        System.out.println(now);
    }
}

2.秒杀核心

创建一个秒杀服务接口

public interface SecKillService {
    void buy(String goodsId, String userId);
}

　

package shop.seckill.example.service.imp;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.serializer.SerializerFeature;
import com.google.common.collect.Maps;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import scf.frame.starter.cache.redis.JedisUtil;
import shop.seckill.example.service.SecKillService;
import shop.seckill.example.utils.SystemTimeUtil;

import java.util.Date;
import java.util.Map;

/**
 * @author IT006448
 * @date 2022/01/14
 */
@Service
@Slf4j
public class SecKillServiceImpl implements SecKillService {
    @Autowired
    private JedisUtil jedisUtil;
    public static Map<String, Integer> inventoryMap = Maps.newLinkedHashMap();

    {
        inventoryMap.put("10001", 10);
    }


    @Override
    public void buy(String goodsId, String userId) {
        String key = "SECKILL_USER_".concat(goodsId);

        //用户开抢时间
        //long startTime = System.currentTimeMillis();
        //System.currentTimeMillis并发性能太差，用定时任务去获取，性能更好
        long startTime = SystemTimeUtil.now();
        int timeout = 10000;
        //未抢到的情况下，10秒内继续获取锁
        while ((startTime + timeout) >= SystemTimeUtil.now()) {
            String strInventory = jedisUtil.getStr(goodsId + "_INVENTORY_NUM");
            //商品是否剩余
            System.out.println(getDate() + " 库存数量:" + strInventory);
            if (strInventory != null && Integer.parseInt(strInventory) <= 0) {
                System.out.println("商品没有剩余了，跳出");
                break;
            }

            //获取锁
            boolean lock = jedisUtil.setIfAbsent(key, userId);
            if (lock) {
                //加锁成功
                try {
                    jedisUtil.expire(key, 60);
                    parallelBuy(goodsId, userId);
                    return;
                } finally {
                    jedisUtil.del(key);
                }
            } else {
                System.out.println(String.format("用户:%s锁了,等待买", userId));
            }
        }
    }

    public void parallelBuy(String goodsId, String userId) {
        Integer inventory = inventoryMap.get(goodsId);
        try {
            //模拟减去库存等操作耗时
            Thread.sleep(1000);
        } catch (Exception e) {
        }
        if (inventory <= 0) {
            System.out.println("商品已经卖完");
            return;
            //throw new RuntimeException("商品:".concat(goodsId).concat("已经卖完"));
        }
        --inventory;
        jedisUtil.set(goodsId + "_INVENTORY_NUM", inventory.toString(), 60);
        System.out.println(getDate() + " 还剩下:".concat(inventory.toString()));
        System.out.println(String.format(getDate() + " 用户:%s买了一件", userId));
        inventoryMap.put(goodsId, inventory);
    }

    public String getDate() {
        return JSON.toJSONString(new Date(), SerializerFeature.UseISO8601DateFormat);
    }
}

3.模拟创建100个随机用户，并并发执行

package shop.seckill.example.service.imp;

import com.alibaba.fastjson.JSON;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.StopWatch;
import shop.seckill.example.service.SecKillService;

import java.util.LinkedList;
import java.util.List;
import java.util.stream.IntStream;

/**
 * @author IT006448
 * @date 2022/01/14
 */
@Service
@Slf4j
public class ShopServiceImpl implements ShopService {
    @Autowired
    private SecKillService secKillService;

    @Override
    public void buy() {
        List<String> user = createUser();
        StopWatch stopWatch = new StopWatch();
        stopWatch.start();
        log.info("用户:{}", JSON.toJSONString(user));
        user.parallelStream().forEach(x -> {
            secKillService.buy("10001", x);
        });
        stopWatch.stop();

        double totalTimeSeconds = stopWatch.getTotalTimeSeconds();
        System.out.println("运行总时间:" + totalTimeSeconds);
        System.out.println("库存数量:" + SecKillServiceImpl.inventoryMap.get("10001"));

    }

    public List<String> createUser() {
        List<String> user = new LinkedList<>();
        IntStream.range(0, 100).parallel().forEach(x -> {
            user.add("用户" + x);
        });
        return user;
    }
}