Redis分布式锁的几种实现方法_Redis

redis基本命令：

// 设置键mykey的值为myvalue，并且该键在10秒后过期
set mykey myvalue ex 10
// 设置键mykey的值为myvalue，并且该键在1000毫秒（1秒）后过期
set mykey myvalue px 1000
// 指定key过期时间，单位是秒，过期后自动删除
expire key_name second_num
// 指定key过期时间，单位是毫秒，过期后自动删除
pexpire key_name millisecond_num

// 返回key过期时间
ttl key_name 

set key value	 //设置键key的值为value
setnx key value	 //只有在键key不存在的情况下，将key的值设置为value
setex key seconds value	 //将键key的值设置为value，并且超时时间为seconds秒
psetex key milliseconds value  //将键key的值设置为value，并且超时时间为milliseconds毫秒

一、基础方案：setnx命令实现

public class simpleredislock {
    private jedis jedis;
    private string lockkey;

    public simpleredislock(jedis jedis, string lockkey) {
        this.jedis = jedis;
        this.lockkey = lockkey;
    }
    public boolean trylock() {
        long result = jedis.setnx(lockkey, "locked");
        if (result == 1) {
            jedis.expire(lockkey, 30); // 设置过期时间
            return true;
        }
        return false;
    }
    public void unlock() {
        jedis.del(lockkey);
    }
}

// 使用示例
jedis jedis = new jedis("localhost");
simpleredislock lock = new simpleredislock(jedis, "order_lock");
try{
    if(lock.trylock()){
    // 业务逻辑
    }
} finally {
    lock.unlock();
}

问题分析：

非原子操作：setnx和expire非原子操作，可能产生死锁
锁误删：任何客户端都可以删除锁
不可重入：同一线程重复获取会失败

二、改进方案：原子set命令

public class atomicredislock {
    private jedis jedis;
    private string lockkey;
    private string clientid;

    public simpleredislock(jedis jedis, string lockkey) {
        this.jedis = jedis;
        this.lockkey = lockkey;
        this.clientid = uuid.randomuuid().tostring();
    }
    public boolean trylock(int expireseconds) {
        string result = jedis.set(lockkey, clientid, setparams.setparams().nx().ex(expireseconds));
        return "ok".equals(result);
    }
    public boolean unlock() {
        string script = "if redis.call('get', keys[1]) == argv[1] then " +
                "return redis.call('del', keys[1]) " +
                "else return 0 end";
        object result = jedis.eval(script, collections.singletonlist(lockkey), collections.singletonlist(clientid));
        return result.equals(1l);
    }
}

// 使用示例
jedis jedis = new jedis("localhost");
atomicredislock lock = new atomicredislock(jedis, "payment_lock");
try{
    if(lock.trylock(30)){
    // 业务逻辑
    }
} finally {
    lock.unlock();
}

核心改进：

使用原子set命令：set key value nx ex
lua脚本保证删除原子性
客户端唯一标识防止误删

仍然存在的问题：

锁续期困难
单点故障风险
业务超时可能导致锁失效

三、高可用方案：redlock算法

public class redlock {
    pprivate list<jedis> jedislist;
    private string lockkey;
    private string clientid;
    private int quorum;

    public redlock(list<jedis> jedislist, string lockkey) {
        this.jedislist = jedislist;
        this.lockkey = lockkey;
        this.clientid = uuid.randomuuid().tostring();
        this.quorum = jedislist.size() / 2 + 1;
    }
    public boolean trylock(int expiremillis) {
        long starttime = system.currenttimemillis();
        // 第一阶段：尝试获取多数节点锁
        int successcount = 0;
        for (jedis jedis : jedislist) {
            if (tryacquire(jedis, expiremillis)) {
                successcount++;
            }
            if ((system.currenttimemillis() - starttime) > expiremillis) {
                break;
            }
        }
        // 第二阶段：验证锁有效性
        if (successcount >= quorum) {
            long validitytime = expiremillis - (system.currenttimemillis() - starttime);
            return validitytime > 0;
        }
        // 第三阶段：释放已获得的锁
        for (jedis jedis : jedislist) {
            release(jedis);
        }
        return false;
    }
    private boolean tryacquire(jedis jedis, long expiremillis) {
        try {
            string result = jedis.set(lockkey, clientid, setparams.setparams().nx().px(expiremillis));
            return "ok".equals(result);
        } catch (exception e) {
            return false;
        }
    }
    private void release(jedis jedis) {
        string script = "if redis.call('get', keys[1]) == argv[1] then " +
                "return redis.call('del', keys[1]) else return 0 end";
        jedis.eval(script, collections.singletonlist(lockkey), collections.singletonlist(clientid));
    }
}

部署要求：

至少5个独立redis实例
节点间时钟同步
需要配置合理的超时时间

适用场景：

金融交易等对可靠性要求极高的场景
需要跨机房部署的分布式系统

四、生产级方案：redisson实现

// 配置redisson客户端
config config = new config();
config.usesingleserver().setaddress("redis://127.0.0.1:6379");
redissonclient redisson = redisson.create(config);
// 获取锁对象
rlock lock = redisson.getlock("orderlock");
try {
    // 尝试加锁，最多等待100秒，锁定后30秒自动解锁
    boolean islock = lock.trylock(100, 30, timeunit.seconds);
    if (islock) {
        // 处理业务
    }
} finally {
    lock.unlock();
}

// 关闭客户端
redisson.shutdown();

// 自动续期机制（watchdog），watchdog实现原理（简化版）
private void renewexpiration() {
    timeout task = commandexecutor.schedule(() -> {
        if (redisclient.eval(...)){ // 检查是否仍持有锁
            expireasync(); // 续期
            renewexpiration(); // 递归调用
        }
    }, internallockleasetime / 3, timeunit.milliseconds);
}

核心特性：