Java实现Redisson分布式锁的10大陷阱与避坑指南

<!-- maven依赖配置 -->
<dependency>
    <groupid>org.redisson</groupid>
    <artifactid>redisson</artifactid>
    <version>3.18.0</version>
</dependency>

singleserverconfig:
  address: "redis://127.0.0.1:6379"
  database: 0
  connectionpoolsize: 64
  connectionminimumidlesize: 10

// 获取分布式锁实例
rlock lock = redissonclient.getlock("mylock");
// 方式1：阻塞式加锁（推荐用法）
lock.lock();
try {
    // 执行业务逻辑
    executebusiness();
} finally {
    // 确保锁被释放
    lock.unlock();
}
// 方式2：带超时的尝试加锁
boolean islocked = lock.trylock(10, 30, timeunit.seconds);
if (islocked) {
    try {
        executebusiness();
    } finally {
        lock.unlock();
    }
}
// 方式3：异步加锁
rfuture<void> lockfuture = lock.lockasync();
lockfuture.whencomplete((result, exception) -> {
    try {
        executebusiness();
    } finally {
        lock.unlockasync();
    }
});

// 获取公平锁实例（按请求顺序获得锁）
rlock fairlock = redissonclient.getfairlock("fairlock");
fairlock.lock();
try {
    // 业务逻辑
} finally {
    fairlock.unlock();
}

// 读写锁实现读多写少场景
rreadwritelock rwlock = redissonclient.getreadwritelock("rwlock");
// 读锁（共享锁，允许多个线程同时持有）
rlock readlock = rwlock.readlock();
readlock.lock();
try {
    // 读取操作
} finally {
    readlock.unlock();
}
// 写锁（排他锁，只能有一个线程持有）
rlock writelock = rwlock.writelock();
writelock.lock();
try {
    // 写入操作
} finally {
    writelock.unlock();
}

// 同时锁定多个资源
rlock lock1 = redissonclient.getlock("lock1");
rlock lock2 = redissonclient.getlock("lock2");
rlock lock3 = redissonclient.getlock("lock3");
redissonmultilock multilock = new redissonmultilock(lock1, lock2, lock3);
multilock.lock();
try {
    // 操作多个资源的业务逻辑
} finally {
    multilock.unlock();
}

// 红锁（redlock算法，需要多个redis实例）
config config1 = new config();
config1.usesingleserver().setaddress("redis://127.0.0.1:6379");
redissonclient client1 = redisson.create(config1);
config config2 = new config();
config2.usesingleserver().setaddress("redis://127.0.0.1:6380");
redissonclient client2 = redisson.create(config2);
rlock lock1 = client1.getlock("lock");
rlock lock2 = client2.getlock("lock");
redissonredlock redlock = new redissonredlock(lock1, lock2);
redlock.lock();
try {
    // 高安全要求的业务逻辑
} finally {
    redlock.unlock();
}

// ❌ 错误示例：锁过期时间太短
lock.lock(5, timeunit.seconds);  // 业务如果超过5秒会出问题
// ✅ 正确做法：合理评估并设置锁超时时间
// 或者使用看门狗机制（默认30秒，每10秒续期）
lock.lock();  // 使用看门狗自动续期
// ✅ 或明确指定足够长的超时时间
lock.lock(30, timeunit.seconds);

// ❌ 错误示例：未在finally中释放锁
lock.lock();
executebusiness();
// 如果这里抛出异常，锁永远不会释放
// ✅ 正确示例：确保锁释放
lock.lock();
try {
    executebusiness();
} finally {
    // 检查当前线程是否持有锁
    if (lock.isheldbycurrentthread()) {
        lock.unlock();
    }
}

// ❌ 错误示例：在递归调用中重复加锁
public void recursivemethod(int n) {
    lock.lock();
    try {
        if (n > 0) {
            recursivemethod(n - 1);  // 重复获取锁，造成死锁
        }
    } finally {
        lock.unlock();
    }
}
// ✅ 正确示例：redisson锁支持可重入
public void recursivemethod(int n) {
    lock.lock();
    try {
        if (n > 0) {
            recursivemethod(n - 1);  // 可重入锁，不会死锁
        }
    } finally {
        lock.unlock();
    }
}

// ❌ 错误示例：主从切换导致锁丢失
// 在主从架构中，主节点写入锁后未同步到从节点就宕机
// ✅ 解决方案1：使用红锁（redlock）
redissonredlock redlock = new redissonredlock(lock1, lock2, lock3);
// ✅ 解决方案2：使用高可用集群模式
config config = new config();
config.useclusterservers()
    .addnodeaddress("redis://127.0.0.1:7001")
    .addnodeaddress("redis://127.0.0.1:7002")
    .addnodeaddress("redis://127.0.0.1:7003");

// ✅ 使用业务相关的有意义的锁名
// 格式：业务:资源类型:资源标识
string lockkey = "order:pay:lock:" + orderid;
rlock lock = redissonclient.getlock(lockkey);
// ❌ 避免使用通用锁名
rlock badlock = redissonclient.getlock("lock");  // 过于通用，易冲突

// ❌ 锁粒度过粗（性能瓶颈）
rlock globallock = redissonclient.getlock("globalorderlock");
// ❌ 锁粒度过细（管理复杂）
rlock itemlock = redissonclient.getlock("orderitem:" + itemid + ":" + userid);
// ✅ 合适的锁粒度
rlock orderlock = redissonclient.getlock("order:" + orderid);

// 配置合理的重试策略
boolean locked = false;
int retrycount = 0;
int maxretries = 3;
while (!locked && retrycount < maxretries) {
    try {
        locked = lock.trylock(100, 10000, timeunit.milliseconds);
        if (locked) {
            // 执行业务逻辑
            executebusiness();
        }
    } catch (interruptedexception e) {
        thread.currentthread().interrupt();
        break;
    } finally {
        if (locked) {
            lock.unlock();
        }
    }
    retrycount++;
    if (!locked && retrycount < maxretries) {
        thread.sleep(100 * retrycount); // 指数退避
    }
}

// 添加锁操作的监控点
@slf4j
@component
public class distributedlockservice {
    @autowired
    private redissonclient redissonclient;
    public <t> t executewithlock(string lockkey, long waittime, long leasetime, 
                                supplier<t> supplier) {
        rlock lock = redissonclient.getlock(lockkey);
        long start = system.currenttimemillis();
        try {
            boolean acquired = lock.trylock(waittime, leasetime, timeunit.milliseconds);
            if (!acquired) {
                log.warn("获取锁失败，lockkey: {}", lockkey);
                throw new lockacquireexception("获取分布式锁失败");
            }
            log.info("成功获取锁，lockkey: {}, 耗时: {}ms", 
                    lockkey, system.currenttimemillis() - start);
            return supplier.get();
        } catch (interruptedexception e) {
            thread.currentthread().interrupt();
            throw new lockacquireexception("锁获取被中断", e);
        } finally {
            if (lock.isheldbycurrentthread()) {
                lock.unlock();
                log.info("释放锁，lockkey: {}", lockkey);
            }
        }
    }
}

# 优化配置示例
lockwatchdogtimeout: 30000  # 看门狗超时时间
keeppubsuborder: true       # 保持订阅顺序
retryinterval: 300          # 重试间隔（ms）
retryattempts: 3            # 重试次数
timeout: 3000               # 命令超时时间（ms）