Redisson实现Redis分布式锁的几种方式

目录

• redis几种架构
• 普通分布式锁
• 单机模式
• 哨兵模式
• 集群模式
• 总结
• redlock分布式锁
• 实现原理
• 问题合集

前几天发的一篇文章《redlock：redis分布式锁最牛逼的实现》，引起了一些同学的讨论，也有一些同学提出了一些疑问，这是好事儿。本文在讲解如何使用redisson实现redis普通分布式锁，以及redlock算法分布式锁的几种方式的同时，也附带解答这些同学的一些疑问。

redis几种架构

redis发展到现在，几种常见的部署架构有：

• 单机模式；
• 主从模式；
• 哨兵模式；
• 集群模式；

我们首先基于这些架构讲解redisson普通分布式锁实现，需要注意的是，只有充分了解普通分布式锁是如何实现的，才能更好的了解redlock分布式锁的实现，因为redlock分布式锁的实现完全基于普通分布式锁。

普通分布式锁

redis普通分布式锁这个大家基本上只了解，本文不打算过多的介绍，上一篇文章《redlock：redis分布式锁最牛逼的实现》也讲的很细，并且也说到了几个重要的注意点。

所以直接show you the code，毕竟talk is cheap。

redisson版本

本次测试选择redisson 2.14.1版本。

单机模式

源码如下：

// 构造redisson实现分布式锁必要的config
config config = new config();
config.usesingleserver().setaddress("redis://172.29.1.180:5379").setpassword("a123456").setdatabase(0);
// 构造redissonclient
redissonclient redissonclient = redisson.create(config);
// 设置锁定资源名称
rlock dislock = redissonclient.getlock("dislock");
boolean islock;
try {
    //尝试获取分布式锁
    islock = dislock.trylock(500, 15000, timeunit.milliseconds);
    if (islock) {
        //todo if get lock success, do something;
        thread.sleep(15000);
    }
} catch (exception e) {
} finally {
    // 无论如何, 最后都要解锁
    dislock.unlock();
}

通过代码可知，经过redisson的封装，实现redis分布式锁非常方便，我们再看一下redis中的value是啥，和前文分析一样，hash结构，key就是资源名称，field就是uuid+threadid，value就是重入值，在分布式锁时，这个值为1（redisson还可以实现重入锁，那么这个值就取决于重入次数了）：

172.29.1.180:5379> hgetall dislock
1) "01a6d806-d282-4715-9bec-f51b9aa98110:1"
2) "1"

哨兵模式

即sentinel模式，实现代码和单机模式几乎一样，唯一的不同就是config的构造：

config config = new config();
config.usesentinelservers().addsentineladdress(
        "redis://172.29.3.245:26378","redis://172.29.3.245:26379", "redis://172.29.3.245:26380")
        .setmastername("mymaster")
        .setpassword("a123456").setdatabase(0);

集群模式

集群模式构造config如下：

config config = new config();
config.useclusterservers().addnodeaddress(
        "redis://172.29.3.245:6375","redis://172.29.3.245:6376", "redis://172.29.3.245:6377",
        "redis://172.29.3.245:6378","redis://172.29.3.245:6379", "redis://172.29.3.245:6380")
        .setpassword("a123456").setscaninterval(5000);

总结

普通分布式实现非常简单，无论是那种架构，向redis通过eval命令执行lua脚本即可。

redlock分布式锁

那么redlock分布式锁如何实现呢？以单机模式redis架构为例，直接看实现代码：

config config1 = new config();
config1.usesingleserver().setaddress("redis://172.29.1.180:5378")
        .setpassword("a123456").setdatabase(0);
redissonclient redissonclient1 = redisson.create(config1);

config config2 = new config();
config2.usesingleserver().setaddress("redis://172.29.1.180:5379")
        .setpassword("a123456").setdatabase(0);
redissonclient redissonclient2 = redisson.create(config2);

config config3 = new config();
config3.usesingleserver().setaddress("redis://172.29.1.180:5380")
        .setpassword("a123456").setdatabase(0);
redissonclient redissonclient3 = redisson.create(config3);

string resourcename = "redlock";
rlock lock1 = redissonclient1.getlock(resourcename);
rlock lock2 = redissonclient2.getlock(resourcename);
rlock lock3 = redissonclient3.getlock(resourcename);

redissonredlock redlock = new redissonredlock(lock1, lock2, lock3);
boolean islock;
try {
    islock = redlock.trylock(500, 30000, timeunit.milliseconds);
    system.out.println("islock = "+islock);
    if (islock) {
        //todo if get lock success, do something;
        thread.sleep(30000);
    }
} catch (exception e) {
} finally {
    // 无论如何, 最后都要解锁
    system.out.println("");
    redlock.unlock();
}

最核心的变化就是redissonredlock redlock = new redissonredlock(lock1, lock2, lock3);，因为我这里是以三个节点为例。

那么如果是哨兵模式呢？需要搭建3个，或者5个sentinel模式集群（具体多少个，取决于你）。
那么如果是集群模式呢？需要搭建3个，或者5个cluster模式集群（具体多少个，取决于你）。

实现原理

既然核心变化是使用了redissonredlock，那么我们看一下它的源码有什么不同。这个类是redissonmultilock的子类，所以调用trylock方法时，事实上调用了redissonmultilock的trylock方法，精简源码如下：

public boolean trylock(long waittime, long leasetime, timeunit unit) throws interruptedexception {
    // 实现要点之允许加锁失败节点限制
    int failedlockslimit = failedlockslimit();
    list<rlock> acquiredlocks = new arraylist<rlock>(locks.size());
    // 实现要点之遍历所有节点通过eval命令执行lua加锁
    for (listiterator<rlock> iterator = locks.listiterator(); iterator.hasnext();) {
        rlock lock = iterator.next();
        boolean lockacquired;
        try {
            // 对节点尝试加锁
            lockacquired = lock.trylock(awaittime, newleasetime, timeunit.milliseconds);
        } catch (redisconnectionclosedexception|redisresponsetimeoutexception e) {
            // 如果抛出这类异常，为了防止加锁成功，但是响应失败，需要解锁
            unlockinner(arrays.aslist(lock));
            lockacquired = false;
        } catch (exception e) {
            // 抛出异常表示获取锁失败
            lockacquired = false;
        }
        
        if (lockacquired) {
            // 成功获取锁集合
            acquiredlocks.add(lock);
        } else {
            // 如果达到了允许加锁失败节点限制，那么break，即此次redlock加锁失败
            if (locks.size() - acquiredlocks.size() == failedlockslimit()) {
                break;
            }               
        }
    }
    return true;
}

很明显，这段源码就是上一篇文章《redlock：redis分布式锁最牛逼的实现》提到的redlock算法的完全实现。

以sentinel模式架构为例，如下图所示，有sentinel-1，sentinel-2，sentinel-3总计3个sentinel模式集群，如果要获取分布式锁，那么需要向这3个sentinel集群通过eval命令执行lua脚本，需要3/2+1=2，即至少2个sentinel集群响应成功，才算成功的以redlock算法获取到分布式锁：

问题合集

根据上面实现原理的分析，这位同学应该是对redlock算法实现有一点点误解，假设我们用5个节点实现redlock算法的分布式锁。那么要么是5个redis单实例，要么是5个sentinel集群，要么是5个cluster集群。而不是一个有5个主节点的cluster集群，然后向每个节点通过eval命令执行lua脚本尝试获取分布式锁，如上图所示。

失效时间如何设置
这个问题的场景是，假设设置失效时间10秒，如果由于某些原因导致10秒还没执行完任务，这时候锁自动失效，导致其他线程也会拿到分布式锁。

这确实是redis分布式最大的问题，不管是普通分布式锁，还是redlock算法分布式锁，都没有解决这个问题。也有一些文章提出了对失效时间续租，即延长失效时间，很明显这又提升了分布式锁的复杂度。另外就笔者了解，没有现成的框架有实现，如果有哪位知道，可以告诉我，万分感谢。

redis分布式锁的高可用
关于redis分布式锁的安全性问题，在分布式系统专家martin kleppmann和redis的作者antirez之间已经发生过一场争论。有兴趣的同学，搜索"基于redis的分布式锁到底安全吗"就能得到你想要的答案，需要注意的是，有上下两篇（这应该就是传说中的神仙打架吧，哈）。

zookeeper or redis
没有绝对的好坏，只有更适合自己的业务。就性能而言，redis很明显优于zookeeper；就分布式锁实现的健壮性而言，zookeeper很明显优于redis。如何选择，取决于你的业务！

到此这篇关于redisson实现redis分布式锁的几种方式的文章就介绍到这了,更多相关redisson实现redis分布式锁内容请搜索以前的文章或继续浏览下面的相关文章希望大家以后多多支持！