3 Redis的缓存问题 & Redisson & 超卖的解决方案

setnx key value   
# 当key 不存在的时候 才会set 值
在 stringRedisTemplate 中 调用的是.opsForValue().setIfAbsent("key",value); 返回一个布尔值

如果单纯这样涉及，就会有所谓的死锁情况，比如项目加锁后，停电，嘎，没有释放锁，锁的key永久都在，所以务必加上key的失效时间

在刁钻一点
加上失效时间 如果写法不对也不能保证100%的没问题

// 格式：   stringRedisTemplate.expire(key,value,time,时间单位)
// 设置 10 秒 失效时间
stringRedisTemplate.expire("flag",10,TimeUtils.Second);

超高并发依旧有问题！！！！


超高并发依旧有问题！！！！



超高并发依旧有问题！！！！


        // 添加标记10秒失效
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent("key",value,10, TimeUtils.Second);

        if(!result){
            return "当前有其他线程正在操作";
        }else{
            //TODO 正常的减少库存
        }finally{
            // 删除key标记
            stringRedisTemplate.delete("key")
        }

        <!-- Redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.15.0</version>
        </dependency>

    @Bean
    public Redisson redisson() {
        Config config = new Config();
        // Redis是单机服务
        config.useSingleServer().setAddress("redis://127.0.0.1:6379").setDatabase(0);
        return (Redisson) Redisson.create(config);
    }

    @Autowired
    Redisson redisson;


    String lockKey = "自定义一个key(一般是用户Id锁自己的操作)";
    RLock redissonLock = redisson.getLock(lockKey);
    try{
        redissonLock.lock();
        //TODO 执行操作 
    }finally{
        redissonLock.unlock();
    }

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Configuration;
import org.springframework.transaction.annotation.Transactional;

import java.util.concurrent.TimeUnit;

@Configuration
public class RedissLockUtil {


    /* 尝试获取锁
     *
     * @param lockKey   锁名
     * @param unit      时间单位
     * @param waitTime  最多等待时间
     * @param leaseTime 上锁后自动释放锁时间
     * @return
     */
    public static boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379").setDatabase(0);
        RedissonClient redissonClient = Redisson.create(config);
        RLock lock = redissonClient.getLock(lockKey);
        try {
            return lock.tryLock(waitTime, leaseTime, unit);
        } catch (InterruptedException e) {
            return false;
        }
    }


    /*
     * 释放锁
     *
     * @param lockKey 锁名
     */
    public static void unlock(String lockKey) {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://127.0.0.1:6379").setDatabase(0);
        RedissonClient redissonClient = Redisson.create(config);
        RLock lock = redissonClient.getLock(lockKey);
        // 在解锁之前先判断要解锁的key是否已被锁定并且是否被当前线程保持。 如果满足条件时才解锁
        if (lock.isLocked()) {
            if (lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    
    // 常规的业务逻辑代码
    @Transactional
    public String RedissonForDemo() throws Exception {
        boolean flag = false;
        // 定义一个锁
        String LockName = "所有线程拿这个锁(比如商品数量)";
        // 通过flag判断加锁是否成功
        try {
            flag = RedissLockUtil.tryLock(LockName, TimeUnit.SECONDS, 3, 10);
            if (flag) {
                //TODO 执行自己的业务逻辑 先查询订单数量，再下单。
                return "下单成功！";
            } else {
                return "没有加锁成功,下单失败！";
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            // 一旦加锁成功，方法结束必须要释放锁
            if (flag) {
                RedissLockUtil.unlock(LockName);
            }
        }
        return "方法结束";
    }

}