分布式锁与Redission实现

最新推荐文章于 2024-09-21 23:42:27 发布

DaveStudio

最新推荐文章于 2024-09-21 23:42:27 发布

阅读量481

点赞数

本文链接：https://blog.csdn.net/qq_39863690/article/details/104834157

版权

分布式专栏收录该内容

2 篇文章 0 订阅

订阅专栏

为什么会引出分布式锁

原始项目单tomcat运行，不会存在这种情况，系统分布式架构部署时候，便于资源的锁定，例如多台服

务器执行定时任务线上就可能会引发问题。

Synchornized 是针对于 java进程锁，基于JVM，当一个系统部署在多个节点，多个实例的时候，也无法

完成锁对线程的控制，因此引出分布式锁。

首先看一个基于最基本的redisTemplate实现的分布式锁：在这里插入图片描述

需要注意一下几点：

1: 在给一个key加锁的时候，给一个唯一的value，例如上图用uuid生成，防止在删除key的时候，误删

2: 一个key有效时间的问题，可以通过子线程实现Timer，续时间，每当key还存在的时候，就追加几秒

Redisson又是如何实现的呢

1: 添加依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.8.2</version>
</dependency>

2:配置文件

以springboot为基础，以单体redis机器为例子，当然支持集群部署

在这里插入图片描述
类似于Jedis，会自动创建一个Redisson客户端，从而在使用的时候，直接通过注入使用

@Resource 
private Redission redission;

3:实现分布式锁

String lockKey = “keyName”;

//获取到当前key的锁
Rlock redissionLock = redission.getLock(lockKey);

//上锁默认超时时间 30s
redissionLock.lock();

redission底层上锁机制就是基于lua 脚本的原子性

即使是一大堆复杂的业务逻辑，也可以通过封装在lua脚本中发送给redis

//org.redisson.RedissonLock#tryLockInnerAsync
return this.commandExecutor.evalWriteAsync(this.getName(), LongCodec.INSTANCE, command, 
    "if (redis.call('exists', KEYS[1]) == 0) then 
        redis.call('hset', KEYS[1], ARGV[2], 1); 
        redis.call('pexpire', KEYS[1], ARGV[1]); 
            return nil; 
    end; 
    if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then 
        redis.call('hincrby', KEYS[1], ARGV[2], 1); 
        redis.call('pexpire', KEYS[1], ARGV[1]); 
        return nil; 
    end; 
return redis.call('pttl', KEYS[1]);"
, Collections.singletonList(this.getName()), new Object[]{this.internalLockLeaseTime, this.getLockName(threadId)});

KEYS[1]代表的是你加锁的那个key 就是上文所述keyName

ARGV[1]代表的就是锁key的默认生存时间，默认30秒。从而使得他的延期机制就是 30 * 1/3 = 10s，就

是一个后台子线程，每隔10秒检查一下，如果还持有锁，就再续时间。

ARGV[2]代表的是加锁的客户端的ID，类似于下面这样：

8743c9c0-0795-4907-87fd-6c719a6b4586:1

第一段if判断语句，就是用“exists myLock”命令判断一下，如果你要加锁的那个锁key不存在的话，你就

进行加锁。

如何加锁呢？很简单，用下面的命令：

hset myLock

8743c9c0-0795-4907-87fd-6c719a6b4586:1 1

可重入加锁机制

RLock lock = redisson.getLock("myLock")
lock.lock();
//业务代码
lock.lock();
//业务代码
lock.unlock();
lock.unlock();

通过分析底层lua脚本

第一个if判断肯定不成立，“exists myLock”会显示锁key已经存在了。

第二个if判断会成立，因为myLock的hash数据结构中包含的那个ID，就是客户端1的那个ID，也就是“8743c9c0-0795-4907-87fd-6c719a6b4586:1”

此时就会执行可重入加锁的逻辑，他会用：

incrby keyName

8743c9c0-0795-4907-87fd-6c71a6b4586:1 1

通过这个命令，对客户端1的加锁次数，累加1。

此时keyName数据结构变为下面这样：

myLock:
    {
        8743c9c0-0795-4907-87fd-6c719a6b4586:1 2
    }

锁互斥机制

那么在这个时候，如果客户端2来尝试加锁，执行了同样的一段lua脚本，会咋样呢？

很简单，第一个if判断会执行“exists myLock”，发现myLock这个锁key已经存在了。

接着第二个if判断，判断一下，myLock锁key的hash数据结构中，是否包含客户端2的ID，结果并不是。

所以，客户端2会获取到pttl myLock返回的一个数字，这个数字代表了myLock这个锁key的剩余生存时
间。比如还剩1500毫秒的生存时间。

此时客户端2会进入一个while循环，不停的尝试加锁。

释放锁*

redission.unlock();

其实说白了，就是每次都对myLock数据结构中的那个加锁次数减1。

如果发现加锁次数是0了，说明这个客户端已经不再持有锁了，此时就会用：

“del myLock”命令，从redis里删除这个key。

然后呢，另外的客户端2就可以尝试完成加锁了。

这就是所谓的分布式锁的开源Redisson框架的实现机制。

一般我们在生产系统中，可以用Redisson框架提供的这个类库来基于redis进行分布式锁的加锁与释放锁。

优点

支持redis单实例、redis哨兵、redis cluster、redis master-slave等各种部署架构，基于Redis 所以具有Redis 功能使用的封装，功能齐全。许多公司试用后可以用到企业级项目中，社区活跃度高。

在springboot 中单机及哨兵自动装配如下

    /**
     * 哨兵模式自动装配
     * @return
     */
    @Bean
    @ConditionalOnProperty(name="redisson.master-name")
    RedissonClient redissonSentinel() {
        Config config = new Config();
        SentinelServersConfig serverConfig = config.useSentinelServers().addSentinelAddress(redssionProperties.getSentinelAddresses())
                .setMasterName(redssionProperties.getMasterName())
                .setTimeout(redssionProperties.getTimeout())
                .setMasterConnectionPoolSize(redssionProperties.getMasterConnectionPoolSize())
                .setSlaveConnectionPoolSize(redssionProperties.getSlaveConnectionPoolSize());
        
        if(StringUtils.isNotBlank(redssionProperties.getPassword())) {
            serverConfig.setPassword(redssionProperties.getPassword());
        }
        return Redisson.create(config);
    }

    /**
     * 单机模式自动装配
     * @return
     */
    @Bean
    @ConditionalOnProperty(name="redisson.address")
    RedissonClient redissonSingle() {
        Config config = new Config();
        SingleServerConfig serverConfig = config.useSingleServer()
                .setAddress(redssionProperties.getAddress())
                .setTimeout(redssionProperties.getTimeout())
                .setConnectionPoolSize(redssionProperties.getConnectionPoolSize())
                .setConnectionMinimumIdleSize(redssionProperties.getConnectionMinimumIdleSize());
        
        if(StringUtils.isNotBlank(redssionProperties.getPassword())) {
            serverConfig.setPassword(redssionProperties.getPassword());
        }

        return Redisson.create(config);
    }