Redis分布式锁防止库存击穿

Redis分布式锁防止库存击穿

配置类

#redis配置
spring.redis.host=x.x.x.x
spring.redis.password=x@x@x
spring.redis.port=6379
##Redis数据库索引（默认为0）
spring.redis.database=0
spring.redis.timeout=30000
spring.redis.maxTotal=30
spring.redis.maxIdle=10
spring.redis.maxWaitMillis=1500
spring.redis.blockWhenExhausted=false
spring.redis.JmxEnabled=true
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.poll.max-active=50
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.poll.max-wait=3000
# 连接池中的最大空闲连接
spring.redis.jedis.poll.max-idle=20
# 连接池中的最小空闲连接
spring.redis.jedis.poll.min-idle=2
# 连接超时时间（毫秒）
spring.redis.jedis.timeout=5000

## SKU加减库存锁前缀
redis.key.prefix.skuId.lock.reduce=SKU_ID_LOCK_REDUCE:
redis.key.prefix.skuId.lock.add=SKU_ID_LOCK_ADD:

Redis锁公用类

Tips：添加Redis SpringBoot 客户端Client依赖

import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

/**
 * @Description 直接使用Redis进行分布式锁 这是简易版本 如果要使用Redis原生锁记得加过期时间，防止死锁 最好使用Redisson操作简单更加方便
 */
@Component
public class RedisLockCommon {

    @Autowired private StringRedisTemplate stringRedisTemplate;

    /**
     * Redis加锁的操作
     *
     * @param key
     * @param value
     * @return
     */
    public Boolean tryLock(String key, String value) {

        // 加锁
        if (stringRedisTemplate.opsForValue().setIfAbsent(key, value)) {
            return true;
        }

        // 其他人获取不到锁执行如下代码
        // 获取锁的值
        String currentValue = stringRedisTemplate.opsForValue().get(key);

        // 锁的值小于当前时则锁已过期
        if (StringUtils.isNotEmpty(currentValue)
                && Long.parseLong(currentValue) < System.currentTimeMillis()) {
            // 获取上一个锁的时间 如果高并发的情况可能会出现已经被修改的问题  所以多一次判断保证线程的安全
            String oldValue = stringRedisTemplate.opsForValue().getAndSet(key, value);
            // 比较锁的getSet获取到的最近锁值和最开始获取到的锁值，如果不相等则证明锁已经被其他线程获取了
            if (StringUtils.isNotEmpty(oldValue) && oldValue.equals(currentValue)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Redis解锁的操作
     *
     * @param key
     * @param value
     */
    public void unlock(String key, String value) {
        String currentValue = stringRedisTemplate.opsForValue().get(key);
        try {
            if (StringUtils.isNotEmpty(currentValue) && currentValue.equals(value)) {
                stringRedisTemplate.opsForValue().getOperations().delete(key);
            }
        } catch (Exception e) {
        }
    }
}

定义加减库存方法

@Service
@Slf4j
public class SpBuyOrderServiceImpl extends ServiceImpl<SpBuyOrderMapper, SpBuyOrderEntity>
        implements SpBuyOrderService {

    @Autowired private SpSkuMapper spSkuMapper;
    @Autowired private RedisLockCommon redisLock;

    @Value(value = "${redis.key.prefix.skuId.lock.reduce}")
    private String REDIS_PREFIX_SKU_ID_LOCK_REDUCE;

    @Value(value = "${redis.key.prefix.skuId.lock.add}")
    private String REDIS_PREFIX_SKU_ID_LOCK_ADD;
  
    @Override
    public Integer addStock(String skuId) {

        String keyLock = REDIS_PREFIX_SKU_ID_LOCK_ADD + skuId;

        long time = System.currentTimeMillis();

        try {
            // 如果加锁失败
            if (!redisLock.tryLock(keyLock, String.valueOf(time))) {
                log.info("预增库存加锁失败：" + skuId);
                return 0;
            }

            int update = spSkuMapper.addSkuStock(skuId);
            if (1 != update) {
                return 0;
            }

        } catch (Exception e) {
            log.error("库存预增加锁失败：{}", e.getMessage());
            return 0;
        } finally {
            // 解锁
            redisLock.unlock(keyLock, String.valueOf(time));
        }

        return 1;
    }

    @Override
    public Integer reduceStock(String skuId) {

        String keyLock = REDIS_PREFIX_SKU_ID_LOCK_REDUCE + skuId;

        // 设置Redis分布式锁的超时时间，单位ms
        long time = System.currentTimeMillis() + 2000;

        try {
            // 如果加锁失败
            if (!redisLock.tryLock(keyLock, String.valueOf(time))) {
                log.info("预减库存加锁失败：" + skuId);
                return 0;
            }

            // 查询库存，避免高并发环境库存击穿
            LambdaQueryWrapper<SpSkuEntity> lqwSku = new LambdaQueryWrapper<>();
            lqwSku.select(SpSkuEntity::getSkuId, SpSkuEntity::getStock);
            lqwSku.eq(SpSkuEntity::getSkuId, skuId);
            SpSkuEntity spSku = spSkuMapper.selectOne(lqwSku);
            if (spSku == null) {
                return 0;
            }
            if (spSku.getStock() <= 0) {
                return 0;
            }

            int update = spSkuMapper.reduceSkuStock(skuId);
            if (1 != update) {
                return 0;
            }

        } catch (Exception e) {
            log.error("库存预减加锁失败：{}", e.getMessage());
            return 0;
        } finally {
            // 解锁
            // 不设置解锁，超时会自动解锁
            redisLock.unlock(keyLock, String.valueOf(time));
        }

        return 1;
    }
}

使用

// 分布式锁，限制库存击穿
Integer resultRed = this.reduceStock(tradeOrderVoReq.getSkuId());
if (resultRed == 0) {
		log.error("预扣减库存 库存不足" + tradeOrderVoReq.getSkuId());
		return ServerResponse.getInstance().failed().message("火爆抢购中，还有机会，请刷新页面重试");
}

Integer resultAdd = this.addStock(tradeOrderVoReq.getSkuId());
if (resultAdd == 0) {
		log.error("预增加库存 失败" + tradeOrderVoReq.getSkuId());
		return ServerResponse.getInstance().failed().message("火爆抢购中，还有机会，请刷新页面重试");
}