Redisson 分布式锁原理分析

最新推荐文章于 2024-04-03 15:25:43 发布
最新推荐文章于 2024-04-03 15:25:43 发布
阅读量3.1k 收藏 3
点赞数 1
分类专栏： # Redis 文章标签： Redisson 分布式锁
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42402854/article/details/123342331
版权

Redisson是一个 Redis的开源客户端，也提供了分布式锁的实现。

Redisson官网：

  • https://github.com/redisson/redisson/
  • https://redisson.org/

一、Redisson 分布式锁使用

Redisson分布式锁使用起来还是蛮简单的。

1、添加 Redisson 配置类
引入依赖：

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

创建 Redisson 配置类，注入 RedissonClient客户端。

@Configuration
public class RedissonConfig {

	@Value("${spring.redis.host}")
	private String host;

	@Value("${spring.redis.port}")
	private String port;

	@Value("${spring.redis.password}")
	private String password;

	@Bean
	public RedissonClient getRedisson() {
		Config config = new Config();
		/**
		 * reids配置，支持单机、主从、哨兵、集群等配置。这里使用单机配置
		 */
		config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
		return Redisson.create(config);
	}
}

2、使用 Redisson分布式锁

代码如下：

	@Autowired
	private RedisTemplate<String, String> redisTemplate;

	@Autowired
	private RedissonClient redissonClient;

	public void disLockDemo(long productId) {
		String lockKey = "DISTRIBUTE_LOCK:redissonLock:product_" + productId;

		//设置锁定资源名称，并获取分布式锁对象。
		RLock redissonLock = redissonClient.getLock(lockKey);
		//1.加锁
		redissonLock.lock();
		//boolean isLock = disLock.tryLock(500, 15000, TimeUnit.MILLISECONDS);
		try {
			//2.执行业务代码
			// TODO
            
            //if (isLock) {
				// TODO
			//}
		} finally {
			//3.解锁
			redissonLock.unlock();
		}
	}

在这里插入图片描述

二、Redisson 分布式锁源码分析

使用分布式锁必须要考虑的一些问题：

  • 互斥性：在任意时刻，只能有一个进程持有锁。
  • 防死锁：即使有一个进程在持有锁的期间崩溃而未能主动释放锁，要有其他方式去释放锁从而保证其他进程能获取到锁。
  • 不能释放别人的锁：加锁和解锁的必须是同一个进程。
  • 锁的续期问题：业务执行时间超过锁的过期时间时，需要提前给锁的续期。

Redisson 是 Redis 官方推荐分布式锁实现方案，它采用 Watch Dog机制能够很好的解决锁续期的问题。
执行 lua脚本保证了多条命令执行的原子性操作。

带着上面分布式锁的一些问题查看源码。

1、获取分布式锁对象

简单了解一下。

1.1 创建 RedissonClient

我们在配置类中通过 Redisson.create(config)方法创建了 RedissonClient对象，并注入到 IOC容器中。
在这里插入图片描述

1.2 获取分布式锁对象

使用 Redisson 客户端来 获取分布式锁对象。
在这里插入图片描述

2、加锁代码

在这里插入图片描述

    private void lock(long leaseTime, TimeUnit unit, boolean interruptibly) throws InterruptedException {
        //线程id
        long threadId = Thread.currentThread().getId();
        // 1.尝试获取锁
        Long ttl = this.tryAcquire(-1L, leaseTime, unit, threadId);
        if (ttl != null) {
            RFuture<RedissonLockEntry> future = this.subscribe(threadId);
            if (interruptibly) {
                this.commandExecutor.syncSubscriptionInterrupted(future);
            } else {
                this.commandExecutor.syncSubscription(future);
            }

            try {
                //2.死循环，反复去调用tryAcquire尝试获取锁
                while(true) {
                    // 再次尝试获取锁
                    ttl = this.tryAcquire(-1L, leaseTime, unit, threadId);
                    // ttl为null时表示别的线程已经unlock了，自己加锁成功
                    if (ttl == null) {
                        return;
                    }
                    // 3.锁互斥:通过 JDK的信号量 Semaphore来阻塞线程
                    if (ttl >= 0L) {
                        try {                                                  
                            ((RedissonLockEntry)future.getNow()).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                        } catch (InterruptedException var13) {
                            if (interruptibly) {
                                throw var13;
                            }

                            ((RedissonLockEntry)future.getNow()).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                        }
                    } else if (interruptibly) {
                        ((RedissonLockEntry)future.getNow()).getLatch().acquire();
                    } else {
                        ((RedissonLockEntry)future.getNow()).getLatch().acquireUninterruptibly();
                    }
                }
            } finally {
                // 4.无论是否获得锁,都要取消订阅解锁消息
                this.unsubscribe(future, threadId);
            }
        }
    }

2.1 异步加锁机制

查看 tryAcquire()加锁方法。
在这里插入图片描述
通过源码，看到加锁其实是通过一段 lua 脚本实现的，如下：

if (redis.call('exists', KEYS[1]) == 0) then
    redis.call('hincrby', 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]);
  • KEYS[1] 代表的是你加锁的 key。
  • ARGV[1] 代表的是锁 key 的默认生存时间，默认 30 秒。
  • ARGV[2] 代表的是加锁的客户端的线程 ID。通过 getLockName方法组装了一下。
  • ARGV[2] 后面的 1：为了支持可重入锁做的计数统计。

Redisson 实现分布式锁的共享资源的存储结构是 hash数据结构：

key 是锁的名称，field 是客户端 ID，value 是该客户端加锁（可重入）的次数。

假设此时，客户端 1 来尝试加锁，查看加锁的 lua 脚本：

  • 第一段 if 判断语句，如果你要加锁的那个锁 key 不存在的话，进行加锁。此时锁 key不存在，向Redis中设置一个 hash 结构的数据，则客户端 1加锁成功，返回 null。
2.1.1 锁的续期机制

客户端 1 加锁的那个锁 key 默认生存时间才 30 秒，如果超过了 30 秒，客户端 1 还想一直持有这把锁，就需要提前进行锁的续期操作。

Redisson 提供了一个 Watch dog 机制来解决锁的续期问题， 只要客户端 1 一旦加锁成功，就会启动一个 Watch Dog。
进入 scheduleExpirationRenewal方法，重点查看 renewExpiration方法。
在这里插入图片描述
锁续期的 lua 脚本如下：

if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then
    redis.call('pexpire', KEYS[1], ARGV[1]);
    return 1;
end ;
return 0;

从源码我们看到 leaseTime 必须是 -1 才会开启 Watch Dog 机制，我们发现：

  • 如果想开启 Watch Dog 机制必须使用默认的加锁时间为 30s。
  • 如果自己自定义时间，即使用 tryLock，锁并不会延长，不会触发Watch Dog 机制。

Watch Dog 机制其实就是一个后台定时任务线程，获取锁成功之后，会将持有锁的线程放入到一个 RedissonLock.EXPIRATION_RENEWAL_MAP里面，然后每隔 10 秒 （internalLockLeaseTime / 3） 检查一下，如果客户端 1 还持有锁 key（判断客户端是否还持有 key，其实就是遍历 EXPIRATION_RENEWAL_MAP 里面线程 id 然后根据线程 id 去 Redis 中查，如果存在就会延长 key 的时间），那么就会不断的延长锁 key 的生存时间。

如果服务宕机了，Watch Dog 机制线程也就没有了，此时就不会延长 key 的过期时间，到了 30s 之后就会自动过期了，其他线程就可以获取到锁。

2.1.2 可重入加锁机制

Redisson 也是支持可重入锁的，比如：客户端 1 加锁代码：

@Override
public void demo() {
    RLock lock = redissonSingle.getLock("myLock");
    try {
        lock.lock();
        // TODO 执行业务
        //锁重入
        lock.lock();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        // 释放锁
        lock.unlock();
        lock.unlock();
    }
}

此时，如果客户端 1 又来尝试加锁，继续分析加锁的 lua 脚本。

  • 首先，第一个 if 判断，你要加锁的那个锁 key 已经存在了。
  • 然后，第二个 if 判断，判断一下，加锁的那个锁 key的 hash 数据结构中，是否包含客户端 1 的 ID，
  • 此时数据结构的是客户端 1 的 ID，即包含客户端 1的 ID，然后就执行行可重入锁的命令，将 hash 结构的 value数据 + 1，返回 null。

2.2 锁互斥机制

上面客户端 1加锁成功，此时，如果客户端 2 来尝试加锁，继续分析加锁的 lua 脚本：

  • 首先，第一个 if 判断，你要加锁的那个锁 key 已经存在了。
  • 然后，第二个 if 判断，判断一下，加锁的那个锁 key的 hash 数据结构中，是否包含客户端 2 的 ID，如果包含就是执行可重入锁的赋值，此时 hash数据结构是客户端 1 的 ID，不包含客户端 2的 ID，所以，返回加锁的那个锁 key的剩余存活时间。

接着查看 lock方法中的 死循环部分。
在这里插入图片描述
流程大致如下：

  1. 尝试获取锁，返回 null 则说明加锁成功，返回一个ttl，则说明已经存在该锁，ttl 为锁的剩余存活时间。
  2. 如果此时客户端 2 进程获取锁失败，那么使用客户端 2 的线程 id，通过 Redis 的 channel 订阅锁释放的事件。
  3. 进入死循环中，尝试重新获取锁。
  4. 如果在重试中拿到了锁，则直接返回。
  5. 如果锁当前还是被占用的，那么等待释放锁的消息。通过使用了 JDK 的信号量 Semaphore 来阻塞线程，当 ttl 为锁的剩余存活时间为0后，信号量的 release() 方法会被调用，此时被信号量阻塞的等待队列中的一个线程就可以继续尝试获取锁了。

注意：

  • 当锁正在被占用时，等待获取锁的进程并不是真正通过一个 while(true) 死循环去获取锁（占 CPU资源），而时使用 JDK 的信号量 Semaphore 来阻塞线程（间断性的不断尝试获取锁），是会释放 CPU资源的。

3、锁释放代码

在这里插入图片描述

    public RFuture<Void> unlockAsync(long threadId) {
        RPromise<Void> result = new RedissonPromise();
        // 1. 异步释放锁
        RFuture<Boolean> future = this.unlockInnerAsync(threadId);
        // 2. 取消 Watch Dog 机制
        future.onComplete((opStatus, e) -> {
            this.cancelExpirationRenewal(threadId);
            if (e != null) {
                result.tryFailure(e);
            } else if (opStatus == null) {
                IllegalMonitorStateException cause = new IllegalMonitorStateException("attempt to unlock lock, not locked by current thread by node id: " + this.id + " thread-id: " + threadId);
                result.tryFailure(cause);
            } else {
                result.trySuccess((Object)null);
            }
        });
        return result;
    }

3.1 异步释放锁机制

查看 unlockInnerAsync方法。释放锁也是执行的 lua 脚本：

if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then
    return nil;
end ;
local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1);
if (counter > 0) then
    redis.call('pexpire', KEYS[1], ARGV[2]);
    return 0;
else
    redis.call('del', KEYS[1]);
    redis.call('publish', KEYS[2], ARGV[1]);
    return 1;
end ;
return nil;
  • 首先，第一段 if 判断语句，判断 key 是否存在的话，进行加锁。此时锁 key不存在，则客户端 1加锁成功，向Redis中设置一个 hash 结构的数据。返回 null。
  • 然后，第二个 if 判断，判断一下该客户端对应的锁的 hash 结构的 value 值是否递减为 0，
    • 如果递减不为 0，则重入锁的解锁，返回0。
    • 如果递减为 0，则进行删除，返回1。

3.2 取消 Watch Dog机制

查看 cancelExpirationRenewal方法。
在这里插入图片描述
取消 Watch Dog 机制，即将 RedissonLock.EXPIRATION_RENEWAL_MAP 里面的线程 id 删除。

3.3 通知阻塞等待的进程

利用 Redis 的发布订阅机制，广播释放锁的消息，通知阻塞等待的进程（向通道名为 redisson_lock__channel publish 一条 UNLOCK_MESSAGE 信息）。

– 求知若饥，虚心若愚。

Charge8
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Redisson-构建在Redis服务器之上的分布式可扩展Java数据结构
08-08
分布式Java对象包括Set, SetMultimap, ScoredSortedSet, SortedSet, Map, ConcurrentMap, List, ListMultimap, Queue, BlockingQueue等
Redission分布式锁原理
天地孤影任我行的博客
04-13 1758
原理 源码中加锁lua代码 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
Redisson实现分布式锁
最新发布
zhuge_long的专栏
04-03 940
分布式锁
Redis实现分布式锁原理和Redisson框架实现分布式锁，全网最详细讲解
我认不到你的博客
04-09 2317
分布式锁，即分布式系统中的锁。在单体应用中我们通过锁解决的是控制共享资源访问的问题，而分布式锁，就是解决了分布式系统中控制共享资源访问的问题。与单体应用不同的是，分布式系统中竞争共享资源的最小粒度从线程升级成了进程。
Redis【实战篇】---- 分布式锁-redission
在人间负债^
07-02 5687
重入问题：重入问题是指 获得锁的线程可以再次进入到相同的锁的代码块中，可重入锁的意义在于防止死锁，比如HashTable这样的代码中，他的方法都是使用synchronized修饰的，假如他在一个方法内，调用另一个方法，那么此时如果是不可重入的，不就死锁了吗？所以可重入锁他的主要意义是防止死锁，我们的synchronized和Lock锁都是可重入的。不可重试：是指目前的分布式只能尝试一次，我们认为合理的情况是：当线程在获得锁失败后，他应该能再次尝试获得锁。
Redis实现分布式锁的原理：常见问题解析及解决方案、源码解析Redisson的使用
weixin_44440311的博客
06-05 2568
介绍Redis实现分布式锁的原理、常见问题解析与解决方案、源码解析Redisson的使用
Redisson分布式锁
m0_51431003的博客
05-30 2105
创建Redisson客户端和获取RScript实例：首先，我们需要创建一个RedissonClient实例，来构建客户端连接。然后，我们通过该实例的getScript()方法获取RScript实例，方便未来Lua脚本的执行操作。构造键值列表和执行Lua脚本在此步骤中，我们需要构造键值列表，将待释放的锁的key值添加到list中。接下来，在eval()方法中，我们传入了Mode.READ_WRITE来表示脚本需要读写Redis缓存；继而将Lua脚本作为字符串传入第二个参数；
Redis 实现分布式锁
不要让任何事情成为你不去学习的理由。
03-23 1235
什么是分布式锁已经在之前的文章介绍过了，不明白的同学请回头阅读。这篇文章开始介绍分布式锁的具体实现。实现方式有很多，今天介绍如何通过 redis 来实现。 今天介绍最基本的通过 setnx命令来实现，当然还有基于 redis 开源的第三方实现，比如 redisson. SETNX set if not exist，如果 key 不存在，设置指定的值并返回 1，否则不做任何操作返回 0，整个过程是原子操作。 通过该命令来实现锁时需要考虑多线程并发带来的异常情况，比如上一次程序中断导致锁没有释放、死
redis数据结构
u014078904的博客
02-23 325
Redis五种数据结构如下： 对redis来说，所有的key（键）都是字符串。 1.String 字符串类型 是redis中最基本的数据类型，一个key对应一个value。 String类型是二进制安全的，意思是 redis 的 string 可以包含任何数据。如数字，字符串，jpg图片或者序列化的对象。 使用：get 、 set 、 del 、 incr、 decr 等 ...
redis基础数据结构与分布式锁实现
weixin_38370441的博客
04-13 625
redis学习笔记1：redis基础数据结构与分布式锁Redis大纲redis是什么为什么要用 Redis /为什么要用缓存redis性能高的原因不同数据类型的使用场景底层数据结构Redis分布式锁Java锁失效的原因分布式锁的一般实现思路使用redis创建分布式锁：SETNX分布式锁的进化之路redis教程 Redis大纲 是什么 + 优缺点 + 为什么用 性能高的原因 单线程与NIO模型 https://www.cnblogs.com/my_life/articles/5320230.html 单r
分布式架构下基于Redisson实现Redis分布式锁
riemann_的博客
03-10 794
一、前言 作为后台开发，相信大家都对 Redis 并不陌生了。Redis 有三个客户端 Jedis、Redisson、Lettuce。也就是提供基本的驱动来连接操作 Redis 数据库的。我们先简单介绍下这几个客户端的异同。 Jedis：是Redis 的 Java 实现客户端，提供了比较全面的 Redis 命令的支持。 Redisson：实现了分布式和可扩展的 Java 数据结构。 Lettuc...
Redisson 实现分布式锁原理
青鸟飞鱼
08-19 2997
Redisson实现分布式锁 有关Redisson作为实现分布式锁，总的分3大模块来讲。 1、Redisson实现分布式锁原理 2、Redisson实现分布式锁的源码解析 3、Redisson实现分布式锁的项目代码（可以用于实际项目中） 本文只介绍Redisson如何实现分布式锁的原理。 一、高效分布式锁 当我们在设计分布式锁的时候，我们应该考虑分布式锁至少要满足的一些条件，同时考虑如何高效的设计分布式锁，这里我认为以下几点是必须要考虑的。 1、互斥 在分布式高并发的条件下，我们最需要
利用Redisson实现分布式锁及其底层原理解析
lgxzzz的博客
04-01 1126
Redis介绍 redis是一个key-value存储系统。和Memcached类似，它支持存储的value类型相对更多，包括string(字符串)、list(链表)、set(集合)、zset(sorted set --有序集合)和hash（哈希类型）。这些数据类型都支持push/pop、add/remove及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，redis支持各种不同方式的排序。与memcached一样，为了保证效率，数据都是缓存在内存中。区别的是redis会周期性的把更
分布式锁实现原理
weixin_44197154的博客
04-13 531
文章共 10263 字，预计阅读时间：26 分钟。 写在前面 在了解分布式锁具体实现方案之前，我们应该先思考一下使用分布式锁必须要考虑的一些问题。 互斥性：在...
老夫带你深度剖析Redisson实现分布式锁的原理
qq_42986622的博客
10-26 636
Redis实现分布式锁的原理 前面讲了Redis在实际业务场景中的应用，那么下面再来了解一下Redisson功能性场景的应用，也就是大家经常使用的分布式锁的实现场景。 引入redisson依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.16.0</versi
Redisson 不仅仅是分布式锁
兴趣是最好的老师，勤能补拙
05-18 667
Redisson是一个使用Java编写的开源框架，它提供了一系列分布式数据结构和服务，这些服务能够使Java应用具备分布式应用所需的特性和能力。Redisson的主要目标是将Redis作为Java应用程序的数据存储和缓存层，并且尽可能地利用Redis平台提供的高并发、高可用、高性能、高可扩展性等特点。完善的Redis客户端功能，支持单节点、集群、哨兵模式的自动切换，提供了完整的Java原生API，支持所有Redis支持的数据结构以及扩展的的分布式数据结构，
解析redisson的lock
热门推荐
qq_21972587的博客
06-23 1万+
多线程下的数据一致性问题一直都是热点问题，既要考虑到数据的一致，又要考虑实现的效率，在分布式情况下，这又要成为一种新的难题。分布式锁和我们java基础中学习到的synchronized略有不同，synchronized中我们的锁是个对象，当前系统部署在不同的服务实例上，单纯使用synchronized或者lock 已经无法满足对库存一致性的判断。本次主要讲解基于rediss 实现的分布式锁 普通实...
Redis-redisson工具类使用和常用的锁功能
瑶山的博客
04-21 4846
Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务。 pom引入 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <versi
Redis分布式锁实现原理
leofee的博客
09-15 7035
Redis实现分布式锁原理以及Redisson源码分析
redisson分布式锁实现原理
m0_67393828的博客
06-12 5247
一般写法如下： 其实redis分布式锁就是基于redis的hash数据类型实现的，key为：锁名称，即myLock，field为：uuid+threadId，value为：上锁次数，从此可以看出redis锁是可重入的 二：上锁lock 上面值得注意的是：综上： 个人觉得还是指定合适的leaseTime好，能确保系统出现故障未释放锁后，在一定时间内能够主动去释放锁，避免造成死锁获取锁的整体流程： 模拟多线程同时请求锁的情况： （注意redis中锁值得变化） 释放锁的整理流程：锁续时：使用默认过期时间上锁

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值