Redis 实现分布式锁时需要考虑的问题解决方案

// 使用 SETNX 实现分布式锁
boolean acquireLock(Jedis jedis, String lockKey, String clientId, int expireTime) {
    String result = jedis.set(lockKey, clientId, SetParams.setParams().nx().px(expireTime));
    return "OK".equals(result);
}

jedis.set("lockKey", "client1", SetParams.setParams().nx().px(5000));  // 锁自动在5000毫秒后过期

boolean releaseLock(Jedis jedis, String lockKey, String clientId) {
    String lockValue = jedis.get(lockKey);
    if (clientId.equals(lockValue)) {
        jedis.del(lockKey);  // 只有当前客户端持有锁，才释放锁
        return true;
    }
    return false;
}

-- Lua 脚本：确保释放锁的原子性
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end

String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
Object result = jedis.eval(luaScript, Collections.singletonList(lockKey), Collections.singletonList(clientId));

ScheduledExecutorService scheduler = Executors.newScheduledThreadPool(1);
void acquireLockWithRenewal(Jedis jedis, String lockKey, String clientId, int expireTime) {
    // 获取锁
    boolean acquired = acquireLock(jedis, lockKey, clientId, expireTime);
    if (acquired) {
        // 定期续约，确保锁不会自动过期
        scheduler.scheduleAtFixedRate(() -> {
            if (clientId.equals(jedis.get(lockKey))) {
                jedis.pexpire(lockKey, expireTime);
            }
        }, expireTime / 2, expireTime / 2, TimeUnit.MILLISECONDS);
    }
}

+-----------+      +-----------+      +-----------+
|  Redis1   |      |  Redis2   |      |  Redis3   |
+-----------+      +-----------+      +-----------+
      |                   |                   |
      v                   v                   v
获取锁成功           获取锁成功          获取锁失败

import redis.clients.jedis.Jedis;
import redis.clients.jedis.params.SetParams;
import java.util.UUID;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;
public class RedisDistributedLock {
    private Jedis jedis;
    private String lockKey;
    private String clientId;
    private int expireTime;
    private ScheduledExecutorService scheduler;
    public RedisDistributedLock(Jedis jedis, String lockKey, int expireTime) {
        this.jedis = jedis;
        this.lockKey = lockKey;
        this.clientId = UUID.randomUUID().toString();
        this.expireTime = expireTime;
        this.scheduler = Executors.newScheduledThreadPool(1);
    }
    // 获取锁
    public boolean acquireLock() {
        String result = jedis.set(lockKey, clientId, SetParams.setParams().nx().px(expireTime));
        if ("OK".equals(result)) {
            // 开启定时任务，自动续约锁
            scheduler.scheduleAtFixedRate(() -> renewLock(), expireTime / 2, expireTime / 2, TimeUnit.MILLISECONDS);
            return true;
        }
        return false;
    }
    // 续约锁
    private void renewLock() {
        if (clientId.equals(jedis.get(lockKey))) {
            jedis.pexpire(lockKey, expireTime);
        }
    }
    // 释放锁
    public boolean releaseLock() {
        String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
        Object result = jedis.eval(luaScript, Collections.singletonList(lockKey), Collections.singletonList(clientId));
        return "1".equals(result.toString());
    }
    public static void main(String[] args) throws InterruptedException {
        Jedis jedis = new Jedis("localhost", 6379);
        RedisDistributedLock lock = new RedisDistributedLock(jedis, "myLock", 5000);
        // 尝试获取锁
        if (lock.acquireLock()) {
            System.out.println("获取锁成功！");
            // 模拟业务操作
            Thread.sleep(3000);
            // 释放锁
            if (lock.releaseLock()) {
                System.out.println("释放锁成功！");
            }
        } else {
            System.out.println("获取锁失败！");
        }
        jedis.close();
    }
}