Redis高并发场景防止库存数量超卖少卖

/**
 * @description 商品类
 * @author yiridancan
 * @date 2024/3/23 9:06
 */
public class Goods {

    private int id;

    /**
     * 商品名称
     */
    private String name;

    /**
     * 库存数量
     */
    private int inventoryCount;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getInventoryCount() {
        return inventoryCount;
    }

    public void setInventoryCount(int inventoryCount) {
        this.inventoryCount = inventoryCount;
    }
}

import com.yiridancan.reduceInventory.entity.Goods;
import com.yiridancan.reduceInventory.mapper.GoodsMapper;
import com.yiridancan.reduceInventory.service.IGoodsService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.Objects;

/**
 *  商品实现类
 * @author yiridancan
 * @date 2024/3/23 18:35
 */
@Slf4j
@Service
public class GoodsServiceImpl implements IGoodsService {

    @Autowired
    private GoodsMapper goodsMapper;
    /**
     * 扣减库存
     * @param goodsId 商品id
     * @author yiridancan
     * @date 2024/3/23 18:33
     */
    @Override
    public void reduceInventory(int goodsId) {
        //1.根据商品id获取商品库存数量
        Goods goods = goodsMapper.findGoodsInventory(goodsId);
        if(Objects.isNull(goods)){
            log.error("未获取到商品信息");
            return;
        }
        //2.如果库存数量大于0则扣减库存，如果等于0代表没有货物打印错误信息
        if(goods.getInventoryCount() > 0 ){
            //默认扣减库存1
            goods.setInventoryCount(goods.getInventoryCount()-1);
            goodsMapper.updateGoodsInventory(goods);
            log.info("{}扣减库存成功，扣减后库存为：{}",goods.getName(),goods.getInventoryCount());
        }else {
            log.error("{}库存为0",goods.getName());
        }
    }
}

    @Test
	void contextLoads() {
		//商品id
		int goodsId = 1;
		//创建固定数量的线程池
		int num = 20;
		ExecutorService executorService = Executors.newFixedThreadPool(num);
		//模拟20个并发同时请求接口
		for (int i = 0; i < num; i++) {
			executorService.submit(() -> {
					goodsService.reduceInventory(goodsId);
			});
		}
		executorService.shutdown();
		try {
			executorService.awaitTermination(1, TimeUnit.MINUTES);
		} catch (InterruptedException e) {
			throw new RuntimeException(e);
		}
		//获取商品最终库存数量
		Goods goodsInventory = goodsMapper.findGoodsInventory(goodsId);
		if(Objects.isNull(goodsInventory)){
			return;
		}
		log.info("{}商品最终库存为：{}",goodsInventory.getName(),goodsInventory.getInventoryCount());
	}

    /**
     * 通过乐观锁实现扣减库存
     * @author yiridancan
     * @date 2024/3/25 22:33
     * @param goodsId 商品id
     */
    void casReduceInventory(int goodsId);

    /**
     * 通过乐观锁实现扣减库存
     * @param goodsId 商品id
     * @author yiridancan
     * @date 2024/3/25 22:33
     */
    @Override
    public void casReduceInventory(int goodsId) {
        int retryCount = 0;
        //重试次数设置为3，避免无休止的重试占用紫鸢
        while (retryCount <=3){
            //1.根据商品id获取商品信息
            Goods goods = goodsMapper.findGoodsInventory(goodsId);
            if(Objects.isNull(goods) || goods.getInventoryCount() == 0){
                log.error("未获取到商品信息或库存数量不足");
                return;
            }
            //默认扣减库存1
            goods.setInventoryCount(goods.getInventoryCount()-1);
            int updateRow = goodsMapper.updateGoodsInventoryByCAS(goods);
            //如果修改条数大于0代表扣减库存成功
            if(updateRow > 0 ){
                log.info("{}扣减库存成功，扣减后库存为：{}",goods.getName(),goods.getInventoryCount());
                return;
            }
            retryCount++;
            log.error("{}商品被修改过，进行重试！！版本号：{}",goods.getName(),goods.getDataVersion());
        }
    }

<update id="updateGoodsInventoryByCAS">
        update goods set inventory_count=#{inventoryCount},data_version=data_version+1 where id=#{id} and data_version=#{dataVersion}
</update>

local key = KEYS[1] -- 商品的键名
local amount = tonumber(ARGV[1]) -- 扣减的数量

-- 获取商品当前的库存量
local stock = tonumber(redis.call('get', key))

-- 如果库存足够，则减少库存并返回新的库存量
if stock >= amount then
    redis.call('decrby', key, amount)
    return redis.call('get', key)
else
    return "INSUFFICIENT STOCK"
end

/**
     * 通过Redis扣减库存
     *
     * @param goodsId 商品id
     * @author yiridancan
     * @date 2024/3/27 15:48
     */
    @Override
    public void redisReduceInventory(int goodsId) {
        String prefix = "goodsInventory:";
        //将商品数据缓存到Redis中，key是商品id，value是商品库存数量
        goodsMapper.findGoodsAll().forEach(goods -> {
            stringRedisTemplate.opsForValue().set(prefix+goods.getId(),String.valueOf(goods.getInventoryCount()));
        });

        //lua脚本，一般放在文件中
        String script = "local key = KEYS[1] -- 商品的键名\n" +
                "local amount = tonumber(ARGV[1]) -- 扣减的数量\n" +
                "\n" +
                "-- 获取商品当前的库存量\n" +
                "local stock = tonumber(redis.call('get', key))\n" +
                "\n" +
                "-- 如果库存足够，则减少库存并返回新的库存量\n" +
                "if stock >= amount then\n" +
                "    redis.call('decrby', key, amount)\n" +
                "    return redis.call('get', key)\n" +
                "else\n" +
                "    return \"INSUFFICIENT STOCK\"\n" +
                "end\n";

        DefaultRedisScript<String> redisScript = new DefaultRedisScript<>(script, String.class);

        // 创建一个包含库存key的列表
        List<String> keys = Collections.singletonList(prefix + goodsId);
        // 创建一个包含扣减数量的参数列表
        List<String> args = Collections.singletonList(Integer.toString(1));

        // 执行Lua脚本，传入键列表和参数列表
        String result = stringRedisTemplate.execute(redisScript, keys, args.toArray(new String[0]));
        //如果不是库存不足代表扣减成功
        if(!result.equals("INSUFFICIENT STOCK")){
            log.info("扣减库存成功，库存数量：{}",result);
        }else {
            log.error("库存数量不足");
        }
    }