Redisson分布式锁详解（非公平、公平、红锁、联锁）

已于 2023-01-09 17:01:15 修改
阅读量5.1k 收藏 40
点赞数 4
分类专栏： 分布式锁 文章标签： spring boot redis java 分布式
于 2023-01-09 16:30:52 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/mlwsmqq/article/details/128469771
版权

目录

1、分布式锁理解及手动实现

2、Redisson介绍

3、引入依赖

4、Redis配置

5、RedissonConf配置

6、API介绍

7、效果演示

7.1、lock()方法演示

7.2、演示看门狗机制

7.3、演示无看门狗情况

8、公平锁

9、红锁

10、联锁

11、Lua脚本实现可重入分布式锁

1、分布式锁理解及手动实现

Redis实现分布式锁（SETNX）_mlwsmqq的博客-CSDN博客本文详细介绍了什么是分布式锁、分布式锁的特征、应用场景；一步一步的手动实现分布式锁，分析其中需要特别注意的地方，带着大家理清其中的思路；相信对大家会有所帮助https://blog.csdn.net/mlwsmqq/article/details/127723729

2、Redisson介绍

        Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid），是一款具有诸多高性能功能的综合类开源中间件，提供的功能特性及其在项目中所起的作用远大于原生Redis所提供的各种功能，让开发者对Redis的关注进行分离，可以将更多的精力放在处理业务逻辑上。

        Redisson支持Redis多种连接方式（单机、集群、主从、哨兵等），包含分布式锁、布隆过滤器、分布式对象、分布式集合等多种工具。

3、引入依赖

<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.0</version>
</dependency>

4、Redis配置

redis:
  host: 192.168.xx.xx
  port: xxx
  password: xxx
  database: 1
  timeout: 7200s
  jedis:
    pool:
      max-idle: 500
      min-idle: 50
      max-wait: -1
      max-active: -1

5、RedissonConf配置

package com.example.learningexpansion.conf;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cache.annotation.EnableCaching;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@EnableCaching
public class RedissonConf {

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

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

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

	@Bean(destroyMethod = "shutdown")
	public RedissonClient redissonClient(){
		Config config = new Config();
         /**
		 *  连接哨兵：config.useSentinelServers().setMasterName("myMaster").addSentinelAddress()
		 *  连接集群：config.useClusterServers().addNodeAddress()
		 *  连接主从：config.useMasterSlaveServers().setMasterAddress("xxx").addSlaveAddress("xxx")
		 */
        // 连接单机
		config.useSingleServer()
				.setAddress("redis://"+host+":"+port)
				.setPassword(password);
		RedissonClient client = Redisson.create(config);
		return client;
	}

}

6、API介绍

@Api(tags = "Redis")
@RestController
@RequestMapping("/testRedis")
@Slf4j
public class TestRedisController {

    @Resource
	private RedissonClient redissonClient;
    
    @GetMapping("/testRedisson")
	@ApiOperation("Redisson")
	public ResultVO<Object> testRedisson(@RequestParam Long goodsId) {
		RLock lock = redissonClient.getLock("lock_" + goodsId);
		String threadName = Thread.currentThread().getName();
		try {
			// 注意：若设置了锁的过期时间则没有看门狗机制

			// 阻塞，拿不到锁会一直尝试获取；锁的有效期默认30秒，有看门狗机制延长锁的有效期
			lock.lock();

			// 阻塞，加锁成功后设置指定的有效时间，时间到自动释放锁（无论拿到锁线程是否执行结束），前提是没有调用解锁方法；没有看门狗
			lock.lock(10,TimeUnit.SECONDS);

			// 尝试获取锁，加锁成功后启动看门狗；非阻塞，失败立马返回；注意释放锁时要判断是否存在及是否被当前线程保持
			boolean tryLock = lock.tryLock();
			if (!tryLock){
				return ResultUtils.error("加锁失败，请稍后重试！");
			}

			// 在指定时间内尝试获取锁，失败立即返回；有看门狗
			boolean tryLock2 = lock.tryLock(5, TimeUnit.SECONDS);
			if (!tryLock2){
				return ResultUtils.error("加锁失败，请稍后重试！");
			}

			// 指定时间内尝试获取锁，失败立即返回；成功后设置有效时间为指定值，无看门狗
			boolean tryLock1 = lock.tryLock(5, 10, TimeUnit.SECONDS);
			if (!tryLock1){
				return ResultUtils.error("加锁失败，请稍后重试！");
			}

			// 注意：异步加锁需要调用get()方法使线程执行完成，否则会造成多个线程同时拿到锁
			RFuture<Void> voidRFuture = lock.lockAsync();
			voidRFuture.get();

			// 同lock.tryLock();
			RFuture<Boolean> booleanRFuture = lock.tryLockAsync();
			Boolean aBoolean = booleanRFuture.get();
			if (!aBoolean){
				return ResultUtils.error("加锁失败，请稍后成重试！");
			}

			// 注意重载方法中只有一个long时，要传的是线程ID
			RFuture<Boolean> booleanRFuture1 = lock.tryLockAsync(Thread.currentThread().getId());
			Boolean aBoolean1 = booleanRFuture1.get();
			if (!aBoolean1){
				return ResultUtils.error("加锁失败，请稍后重试！");
			}

			// 同lock.tryLock(5, TimeUnit.SECONDS)
			RFuture<Boolean> rFuture = lock.tryLockAsync(3, TimeUnit.SECONDS);
			Boolean aBoolean3 = rFuture.get();
			if (!aBoolean3){
				return ResultUtils.error("加锁失败，请稍后重试！");
			}

			// 同lock.tryLock(5, 10, TimeUnit.SECONDS)
			RFuture<Boolean> booleanRFuture4 = lock.tryLockAsync(3, 10, TimeUnit.SECONDS);
			Boolean aBoolean4 = booleanRFuture4.get();
			if (!aBoolean4){
				return ResultUtils.error("加锁失败，请稍后重试！");
			}

			// 原理同lock.tryLockAsync(3, 10, TimeUnit.SECONDS)，区别在于多个是线程ID的参数
			RFuture<Boolean> booleanRFuture5 = lock.tryLockAsync(3, 10, TimeUnit.SECONDS, Thread.currentThread().getId());
			Boolean aBoolean5 = booleanRFuture5.get();
			if (!aBoolean5) {
				return ResultUtils.error("加锁失败，请稍后重试！");
			}

			log.info("{}：获取到锁", threadName);
			TimeUnit.SECONDS.sleep(5);
			log.info("{}：业务执行结束", threadName);
		} catch (Exception e) {
			log.error("testRedisson exception:", e);
			return ResultUtils.sysError();
		} finally {
			// 判断锁是否存在
			boolean locked = lock.isLocked();
			// 判断锁是否被当前线程保持
			boolean heldByCurrentThread = lock.isHeldByCurrentThread();
			log.info("{}：获取锁状态：{} 是否当前线程保留：{}", threadName, locked, heldByCurrentThread);
			if (locked && heldByCurrentThread) {
				lock.unlock();
				log.info("{}：释放锁", threadName);
			} else {
				log.info("{}：未获得锁不用释放", threadName);
			}
		}
		return ResultUtils.success();
	}

}

 需要注意的一点是只有在不指定锁的过期时间时，看门狗机制才会生效，从源码可知：

if (leaseTime != -1L) {
    this.internalLockLeaseTime = unit.toMillis(leaseTime);
} else {
    this.scheduleExpirationRenewal(threadId);
}

7、效果演示

7.1、lock()方法演示

        使用8701、8702端口同时启动两个服务，传入相同的参数，快速向两个服务各调用一次

        8701服务效果：

2022-12-30 11:10:12.111  INFO 4796 --- [nio-8701-exec-3] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-3：获取到锁
2022-12-30 11:10:17.112  INFO 4796 --- [nio-8701-exec-3] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-3：业务执行结束
2022-12-30 11:10:17.114  INFO 4796 --- [nio-8701-exec-3] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-3：获取锁状态：true 是否当前线程保留：true
2022-12-30 11:10:17.115  INFO 4796 --- [nio-8701-exec-3] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-3：释放锁

        8702服务效果：

2022-12-30 11:10:17.122  INFO 10168 --- [nio-8702-exec-6] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-6：获取到锁
2022-12-30 11:10:22.124  INFO 10168 --- [nio-8702-exec-6] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-6：业务执行结束
2022-12-30 11:10:22.126  INFO 10168 --- [nio-8702-exec-6] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-6：获取锁状态：true 是否当前线程保留：true
2022-12-30 11:10:22.128  INFO 10168 --- [nio-8702-exec-6] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-6：释放锁

        从上述日志可看出：8701服务先拿到锁，执行完业务释放锁后8702服务才能拿到锁，达到了分布式锁想要的效果

7.2、演示看门狗机制

        同样使用lock()方法，不指定过期时间（默认30秒），睡眠40s模拟执行业务，看是否自动续期

         8701服务效果：

2022-12-30 14:41:25.898  INFO 13804 --- [nio-8701-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-1：获取到锁
2022-12-30 14:42:05.899  INFO 13804 --- [nio-8701-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-1：业务执行结束
2022-12-30 14:42:05.901  INFO 13804 --- [nio-8701-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-1：获取锁状态：true 是否当前线程保留：true
2022-12-30 14:42:05.905  INFO 13804 --- [nio-8701-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-1：释放锁

          8702服务效果：

2022-12-30 14:42:05.913  INFO 14320 --- [nio-8702-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-1：获取到锁
2022-12-30 14:42:45.914  INFO 14320 --- [nio-8702-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-1：业务执行结束
2022-12-30 14:42:45.917  INFO 14320 --- [nio-8702-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-1：获取锁状态：true 是否当前线程保留：true
2022-12-30 14:42:45.921  INFO 14320 --- [nio-8702-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-1：释放锁

        从日志可看出每个拿到锁的线程都执行了40s，并且8702服务在8701服务执行到第30s的时候仍然没有拿到锁，说明自动续期生效啦

7.3、演示无看门狗情况

        同样使用lock()方法，指定过期时间为5s，睡眠8s模拟执行业务，看是否自动续期

        8701服务效果：

2022-12-30 14:33:49.840  INFO 12276 --- [nio-8701-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-1：获取到锁
2022-12-30 14:33:57.840  INFO 12276 --- [nio-8701-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-1：业务执行结束
2022-12-30 14:33:57.846  INFO 12276 --- [nio-8701-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-1：获取锁状态：true 是否当前线程保留：false
2022-12-30 14:33:57.846  INFO 12276 --- [nio-8701-exec-1] c.e.l.c.testRedis.TestRedisController    : http-nio-8701-exec-1：未获得锁不用释放

        8702服务效果：

2022-12-30 14:33:54.844  INFO 11932 --- [nio-8702-exec-5] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-5：获取到锁
2022-12-30 14:34:02.845  INFO 11932 --- [nio-8702-exec-5] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-5：业务执行结束
2022-12-30 14:34:02.848  INFO 11932 --- [nio-8702-exec-5] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-5：获取锁状态：false 是否当前线程保留：false
2022-12-30 14:34:02.848  INFO 11932 --- [nio-8702-exec-5] c.e.l.c.testRedis.TestRedisController    : http-nio-8702-exec-5：未获得锁不用释放

        从日志可看出：8701服务先拿到锁执行，5s后锁自动失效被8702服务获取到锁，此时8701的业务仍未执行结束，因此可验证结论--指定过期时间时，不会自动续期

8、公平锁

        Redisson分布式锁支持公平和非公平，上文中使用的是非公平锁

        公平锁遵循先到先得的原则

	@GetMapping("/testFairLock")
	@ApiOperation("公平锁")
	public ResultVO<Object> testFairLock(@RequestParam Long goodsId) {
		RLock fairLock = redissonClient.getFairLock("fairLock_" + goodsId);
		String threadName = Thread.currentThread().getName();
		try {
			fairLock.lock();
			log.info("{}：获得锁，开始执行业务", threadName);
			TimeUnit.SECONDS.sleep(3);
			log.info("{}：执行结束", threadName);
			return ResultUtils.success();
		} catch (Exception e) {
			log.error("testFairLock exception:", e);
			return ResultUtils.sysError();
		} finally {
			boolean locked = fairLock.isLocked();
			boolean heldByCurrentThread = fairLock.isHeldByCurrentThread();
			log.info("{}：获取锁状态：{} 是否当前线程保留：{}", threadName, locked, heldByCurrentThread);
			if (locked && heldByCurrentThread) {
				fairLock.unlock();
				log.info("{}：释放锁成功", threadName);
			} else {
				log.info("{}：未获得锁不用释放", threadName);
			}
		}
	}

9、红锁

        可以使用红锁来解决主从架构锁失效问题：就是说在主从架构系统中，线程A从master中获取到分布式锁，数据还未同步到slave中时master就挂掉了，slave成为新的master，其它线程从新的master获取锁也成功了，就会出现并发安全问题

        红锁算法：

  1.  应用程序获取系统当前时间，毫秒级
  2.  应用程序使用相同的key、value值依次从多个Redis实例中获取锁，如果某一个节点超过一定时间仍然没有获取到锁则直接放弃，尽快尝试从下一个Redis节点获取锁，以避免被宕机的节点阻塞
  3. 计算获取锁的消耗时间=客户端程序当前时间-step1中的时间，获取锁的消耗时间小于总的锁定时间（例如30s）并且半数以上节点（假如有5个节点，则至少有3个节点）获取锁成功，才认为获取锁成功
  4. 计算剩余锁定时间=总的锁定时间-step3中的消耗时间
  5. 如果获取锁失败，对所有的Redis节点释放锁（无论加锁是否成功）
	// 用于Redis集群架构下，这些节点是完全独立的，所以不使用复制或任何其他隐式协调系统
	// 该对象可以用来将多个RLock对象关联为一个红锁，每个RLock对象实例可以来自于不同的Redisson实例
	@GetMapping("/testRedLock")
	@ApiOperation("红锁")
	public ResultVO<Object> testRedLock(@RequestParam Long id) {
		String threadName = Thread.currentThread().getName();
		RLock one = redissonClient.getLock("one_" + id);
		RLock two = redissonClient.getLock("two_" + id);
		RLock three = redissonClient.getLock("three_" + id);
		RedissonMultiLock redLock = new RedissonRedLock(one, two, three);
		try {
			redLock.lock();
			log.info("{}：获得锁，开始执行业务", threadName);
			TimeUnit.SECONDS.sleep(2);
			log.info("{}：执行结束", threadName);
			return ResultUtils.success();
		} catch (Exception e) {
			log.error("testRedLock exception:", e);
			return ResultUtils.sysError();
		} finally {
			// 注意：不能使用isLocked()和isHeldByCurrentThread()方法，会抛出UnsupportedOperationException异常
			redLock.unlock();
			log.info("{}：释放锁成功", threadName);
		}
	}

10、联锁

        联锁（RedissonMultiLock）对象可以将多个RLock对象关联为一个联锁，实现加锁和解锁功能。每个RLock对象实例可以来自于不同的Redisson实例。

        

	@GetMapping("/testMultLock")
	@ApiOperation("联锁")
	public ResultVO<Object> testMultLock(@RequestParam Long id) {
		String threadName = Thread.currentThread().getName();
		RLock one = redissonClient.getLock("one_" + id);
		RLock two = redissonClient.getLock("two_" + id);
		RLock three = redissonClient.getLock("three_" + id);
		RedissonMultiLock multiLock = new RedissonMultiLock(one, two, three);
		try {
			// 所有的锁都上锁成功才算成功
			multiLock.lock();
			log.info("{}：获得锁，开始执行业务", threadName);
			TimeUnit.SECONDS.sleep(3);
			log.info("{}：执行结束", threadName);
			return ResultUtils.success();
		} catch (Exception e) {
			log.error("testMultLock exception:", e);
			return ResultUtils.sysError();
		} finally {
			// 注意：不能使用isLocked()和isHeldByCurrentThread()方法，会抛出UnsupportedOperationException异常
			multiLock.unlock();
			log.info("{}：释放锁成功", threadName);
		}
	}

11、Lua脚本实现可重入分布式锁
Lua脚本实现可重入分布式锁_mlwsmqq的博客-CSDN博客提到分布式锁，那一定绕不开Redisson，在深入Redisson源码时发现它使用了大量的lua脚本，为什么要使用lua脚本呢？答案就是它能够保证Redis操作的原子性；受到Redisson的启发，本文将带领大家一步步的通过lua脚本实现可重入分布式锁，还有两篇关于分布式锁的博客供大家参考。https://blog.csdn.net/mlwsmqq/article/details/128472150

        有任何错误，欢迎大家指正！

        转载请注明出处！转载请注明出处！

        若本文对大家有所启示，请动动小手点赞和收藏哦！！！

mlwsmqq
关注
  • 4
    点赞
  • 踩
  • 40
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java使用Redisson分布式锁实现原理
08-26
Redisson分布式锁 之前的基于注解的锁有一种锁是基本redis的分布式锁，这篇文章主要介绍了Java使用Redisson分布式锁实现原理，非常具有实用价值，需要的朋友可以参考下
Redisson 源码初探 （六）公平锁
wangxuelei036的博客
02-26 918
因为Redisson 默认是非公平锁，client 端互相一起争抢，现在我们继续研究公平锁，为什么要研究？研究分布式锁 不仅仅要研究最基础的锁对吧，我们要把一系列的非公平锁 公平锁 读写锁 RedLock锁，Semaphore CountDownLatch 一系列的研究完，才算真正的研究了分布式锁，对吧 那么公平锁呢，我们知道公平锁需要维持一个有序的获取锁的顺序，可以使用队列也可以使用一些其他的机制，那么我们慢慢来看Redisson的公平锁是如何实现的？ 先找到入口 public static .
Redis分布式锁实现Redisson 15问（面试常问）
qq_35771266的博客
10-28 1004
在一个分布式系统中，由于涉及到多个实例同时对同一个资源加锁的问题，像传统的synchronized、ReentrantLock等单进程情况加锁的api就不再适用，需要使用分布式锁来保证多服务实例之间加锁的安全性。常见的分布式锁的实现方式有zookeeper和redis等。而由于redis分布式锁相对于比较简单，在实际的项目中，redis分布式锁被用于很多实际的业务场景中。
分布式锁 — Redisson 全面解析！
最新发布
Wewe的博客
04-03 744
分布式锁主要是解决集群，分布式下数据一致性的问题。在单机的环境下，应用是在同一进程下的，只需要保证单进程多线程环境中的线程安全性，通过 JAVA 提供的volatile以及concurrent并发包下一些线程安全的类等就可以做到。分布式锁的实现主要有以下方式：基于数据库基于分布式协调系统基于缓存基于redis命令。如:setnx等操作基于redis Lua脚本能力（本文介绍的实现方式 redisson）
记录redisson实现redis分布式事务锁
04-24
自己封装redisson方法，同时通过注解的方式加入redis分布式事务锁，可靠。
redisson分布式锁源码笔记
03-16
1、详述分布式环境下遇到的问题 2、redisson可重入锁源码 3、RLock#lock()方法源码解析 4、看门狗的作用及实现 5、lua脚本加锁逻辑 6、watchdog维持加锁 7、重入锁在lua脚本中的提现 8、latch.countDown()方法源码解析 9、写锁释放逻辑 10、不同客户端不同线程的互斥原则 11、RedLock锁源码剖析 12、RedLock可能存在的问题 13、MultiLock加锁逻辑 14、公平锁加锁逻辑 15、锁超时及自动释放
redisson公平锁与非公平原理
kznsbs的博客
08-16 1025
redis
5.【Redisson源码】公平锁加锁流程
weixiaohuai的博客
12-30 1572
通过lindex指令获取redisson_lock_queue:{fairLock}在List等待队列的第一个元素，因为此时t2、t3线程都在等待队列中，所以会执行zscore redisson_lock_timeout:{fairLock} d23e0d6b-437c-472c-9c9d-2147907ab8f9:47，从zset有序集合中获取d23e0d6b-437c-472c-9c9d-2147907ab8f9:47对应的分数，也就是对应的过时时间，timeout = 1663143100976。
Redisson源码解读-公平锁
王谷雨的博客
11-08 525
本文介绍了Redisson的公平锁，逻辑大体上和普通可重入锁一致，核心在于 lua 脚本，运用了Redis的3种数据类型。
【Redisson分布式锁】Redisson公平锁实现机制
qq_45260619的博客
03-05 1150
上一篇说了 可重入锁 加锁的流程，这个可重入锁其实就是非公平锁，非公平体现在哪里呢？ 体现在当前客户端如果抢锁失败的话，会拿到这个锁的剩余存活时间，会进行等待，等待之后再次去尝试加锁，里边是没有任何排队的逻辑的，因此是非公平锁
【Redisson】Redisson--分布式中几种锁
DreamSun的博客
07-04 1060
Redisson的分布式可重入读写锁RReadWriteLock Java对象实现了java.util.concurrent.locks.ReadWriteLock接口。该对象允许同时有多个读取锁，但是最多只能有一个写入锁。Redisson分布式可重入公平锁也是实现了java.util.concurrent.locks.Lock接口的一种RLock对象。Redisson的分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口，同时还支持自动过期解锁。
Java redisson实现分布式锁原理详解
08-24
主要介绍了Java redisson实现分布式锁原理详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
RedissonDemo:Redisson分布式锁简单使用教程
05-13
简单使用 基本 // 1. 创建配置对象 Config = ... // 2. 创建redisson实例 RedissonClient redisson = Redisson.create(config); // 3. 获得锁对象 RLock lock = redisson.getLock("myLock"); // 4. 上锁 lock.lock(); // 做你想做的。。。。 // 5.解锁 lock.unlock(); 依赖 <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId> <version>3.4.3</version> </dependency> 可运行示例代码 public class RedissonTest { private stat
redisson实现分布式锁原理
08-31
本文将详细介绍redisson实现分布式锁原理。具有很好的参考价值，下面跟着小编一起来看下吧
Redisson分布式锁源码解析
08-27
给大家分享了关于Redisson分布式锁源码相关的知识点内容，有兴趣的朋友们可以参考学习下。
Redisson（2-3）分布式锁实现对比 VS Java的ReentrantLock的FairLock
xxcupid的博客
03-11 1207
Redisson实现了一整套JDK中ReentrantLock的功能，这里对比一下公平锁（Fair）实现的差异和核心的思想。 公平锁存在的意义是为了保证绝对的公平，但是有其弊端，这个在网上有很多相关的解释，就是说绝对的公平不一定是性能最高的，因此和它相对的还有非公平锁，但是费公平锁也有问题，会引发饥饿现象。具体解释也可参见https://blog.csdn.net/xxcupid/article...
Redisson——联合锁和红锁
m0_64363449的博客
09-04 832
联合锁和红锁放在一起来分析，是因为这两种锁实现在Redisson中，关联密切。红锁是官方提出的一个锁方案，大概如下：假设redis集群有5个节点，一个客户端申请锁时，会向所有的节点申请锁，只有大于一半的节点数量返回成功，且耗费的总时间小于锁有效时间，才会判定为拿锁成功，否则会被认定为失败，需要将已经成功的节点锁释放掉。
Redisson--红锁(Redlock)--使用/原理
热门推荐
IT利刃出鞘的博客
01-27 6万+
本文介绍为什么要使用Redis的红锁（Redlock）、什么是Redis的红锁以及Redis红锁的原理。 本文用Redisson来介绍Redis红锁的用法。 Redisson 高版本会根据redisClient的模式来决定getLock返回的锁类型，如果集群模式，满足红锁的条件，则会直接返回红锁。
分布式锁-Redisson
qq_52922453的博客
10-09 8106
和我们本地锁⼀样互斥性是最基本，但是分布式锁需要保证在不同节点的不同线程的互斥。和本地锁⼀样⽀持锁超时，加锁成功之后设置超时时间，以防⽌线程故障导致不释放锁，防。当当前线程加锁成功之后，执⾏添加订单的过程中，如果当前线程出现异常导致⽆法释放。锁过期了，并且被其他线程成功加锁，⼀样会导致当前线程删除其他线程的锁。可重⼊锁：当在⼀个线程中第⼀次成功获取锁之后，在此线程中就可以再次获取。同⼀个节点上的同⼀个线程如果获取了锁之后那么也可以再次获取这个锁。延⻓过期时间，保证业务线程正常执⾏的过程中，锁不会过期。
redisson 分布式锁
10-18
Redisson是一个基于Redis的Java驻内存数据网格（In-Memory Data Grid）。它提供了一系列的分布式Java对象和服务，如分布式锁、分布式集合、分布式对象等。其中，分布式锁是Redisson的核心功能之一。 Redisson分布式锁的实现原理是：利用Redis的单线程特性，在Redis中创建一个key，作为锁的标识，当多个线程同时请求获取锁时，只有一个线程能够成功获取到锁，其他线程则需要等待。当获取到锁的线程执行完任务后，释放锁，其他线程才能够获取到锁并执行任务。 Redisson分布式锁的优点是：实现简单、性能高、可靠性强。但是需要注意的是，在使用Redisson分布式锁时，需要考虑死锁、重入等问题。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值