基于setnx,lua脚本和Redisson详解Redis分布式锁实现的三种方式

@Resource
private StringRedisTemplate stringRedisTemplate;
/**
 * 示例：扣减库存（基础分布式锁实现）
 */
private void order(){
    // 1. 生成唯一锁值（用于校验锁归属，避免误删）
    String lockValue = UUID.randomUUID().toString();
    // 2. 加锁：SETNX + 过期时间（原子操作），30秒自动释放
    Boolean locked = stringRedisTemplate.opsForValue()
            .setIfAbsent("product:1001:lock", lockValue, 30, TimeUnit.SECONDS);
    try {
        // 3. 加锁成功则执行业务逻辑（扣减库存）
        if (locked) {
            Integer count = (Integer) stringRedisTemplate.opsForHash().get("product:1001","number");
            if (count > 0) {
                stringRedisTemplate.opsForHash().put("product:1001", "number", count - 1);
            }
        }
    } finally {
        // 4. 释放锁：先校验锁归属，再删除（非原子操作）
        if (lockValue.equals(stringRedisTemplate.opsForValue().get("product:1001:lock"))) {
            stringRedisTemplate.delete("product:1001:lock");
        }
    }
}

@Resource
private StringRedisTemplate stringRedisTemplate;
private static final String LOCK_KEY = "product:1001:lock";
private static final String STOCK_KEY = "product:1001:number";
private static final long LOCK_TIMEOUT = 30; // 锁超时时间（秒）
private static final long SLEEP_TIME = 100; // 重试间隔（毫秒）
private void order() {
    String lockValue = UUID.randomUUID().toString();
    try {
        // 1. 尝试获取锁（原子加锁）
        Boolean locked = tryAcquireLock(lockValue);
        if (!locked) {
            // 加锁失败可重试/返回失败（示例直接返回，实际可加循环重试）
            return;
        }
        // 2. 执行业务：获取并扣减库存（简化为String结构，避免Hash类型转换问题）
        String stockStr = stringRedisTemplate.opsForValue().get(STOCK_KEY);
        if (stockStr == null || Integer.parseInt(stockStr) <= 0) {
            return;
        }
        stringRedisTemplate.opsForValue().set(STOCK_KEY, String.valueOf(Integer.parseInt(stockStr) - 1));
    } finally {
        // 3. 释放锁：Lua脚本封装“校验+删除”，保证原子性
        releaseLock(lockValue);
    }
}
/**
 * 原子加锁：SET NX EX
 */
private Boolean tryAcquireLock(String lockValue) {
    return stringRedisTemplate.opsForValue()
            .setIfAbsent(LOCK_KEY, lockValue, LOCK_TIMEOUT, TimeUnit.SECONDS);
}
/**
 * 原子释放锁：Lua脚本
 */
private void releaseLock(String lockValue) {
    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
            "return redis.call('del', KEYS[1]) " +
            "else " +
            "return 0 " +
            "end";
    stringRedisTemplate.execute(
            new DefaultRedisScript<>(script, Long.class),
            Arrays.asList(LOCK_KEY),
            lockValue
    );
}

@Resource
private RedissonClient redissonClient;
@Resource
private StringRedisTemplate stringRedisTemplate;
private void order() {
    // 1. 获取分布式锁对象（可重入锁）
    RLock lock = redissonClient.getLock("product:1001:lock");
    try {
        // 2. 加锁：最多等待10秒，锁30秒后自动释放；获取锁成功则执行业务
        if (lock.tryLock(10, 30, TimeUnit.SECONDS)) {
            try {
                // 3. 扣减库存业务逻辑
                Integer count = (Integer) stringRedisTemplate.opsForHash().get("product:1001","number");
                if (count != null && count > 0) {
                    stringRedisTemplate.opsForHash().put("product:1001", "number", count - 1);
                }
            } finally {
                // 4. 手动释放锁（若业务执行完未超时，主动释放）
                lock.unlock();
            }
        }
    } catch (InterruptedException e) {
        // 5. 中断异常处理，恢复线程中断状态
        Thread.currentThread().interrupt();
    }
}