基于Redis的分布式锁 以及 超详细的改进思路

已于 2022-06-25 10:47:10 修改
阅读量650 收藏 2
点赞数 3
分类专栏： Redis 学习笔记 Java 文章标签： redis 分布式 数据库
于 2022-06-22 12:30:16 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/little_stick_i/article/details/125406948
版权
学习笔记 同时被 3 个专栏收录
28 篇文章 4 订阅
订阅专栏
Java
28 篇文章 2 订阅
订阅专栏
Redis
4 篇文章 0 订阅
订阅专栏

文章目录

基于Redis的分布式锁

什么是分布式锁

满足分布式系统或集群模式下多进程可见并且互斥的锁

image-20220621214722784

需要实现的两个基本方法

  1. 获取锁

    • 互斥：确保只能有一个线程获取锁，可以利用setnx的互斥特性

    • 非阻塞：尝试一次，成功返回true，失败返回false

  2. 释放锁

    • 手动释放，DEL key

    • 超时释放：获取锁时添加一个超时时间，避免服务宕机引起的死锁，EXPIRE lock 10

组合

SET lock thread1 NX EX 10 # NX是互斥、EX是设置超时时间

实现思路

image-20220621222715385

第一版代码

package cn.sticki.common.redis.utils;

import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * @author 阿杆
 * @version 1.0
 * @date 2022/6/21 21:57
 */
public class RedisSimpleLock implements ILock {

	private final StringRedisTemplate stringRedisTemplate;

	private final String name;

	private final static String KEY_PREFIX = "lock:";

	public RedisSimpleLock(StringRedisTemplate stringRedisTemplate, String name) {
		this.stringRedisTemplate = stringRedisTemplate;
		this.name = name;
	}

	@Override
	public boolean tryLock(long timeout) {
        // 1. 获取线程标识
        long threadId = Thread.currentThread().getId();
		// 2. 尝试写入redis
		Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(KEY_PREFIX + name, threadId, timeout, TimeUnit.SECONDS);
		// 3. 返回写入情况，成功即获取到锁
		return Boolean.TRUE.equals(success);
	}

	@Override
	public void unlock() {
        // 1. 释放锁
        stringRedisTemplate.delete(KEY_PREFIX + name);
	}

}

改进思路

存在的问题

存在一种情况，按照以下顺序执行：

  1. 线程1获取到锁，开始执行业务，执行过程中发生了阻塞，在阻塞的过程中，锁超时释放了
  2. 线程2获取锁，由于线程1的锁已经超时释放，所以线程2可以成功获取到锁
  3. 线程1业务执行完毕，释放锁，但线程1的锁早就超时释放了，所以释放的是线程2的锁
  4. 线程3获取锁，线程3和线程2并发执行，此时锁并未起到应起的作用。。。

示意图：

image-20220622103055657

解决方案

这个问题，实际上就是释放了不是自己产生的锁，故我们可以通过特定的标识，在释放锁之前判断锁是否是由自己产生的，且只释放自己产生的锁。

可以将线程id存入value，在释放之前判断锁的value是否等于自己的线程id，若等于则说明该锁是当前线程产生的，可以释放。

新的问题

如果我有多个服务器，组成了一个集群，那么不同的服务器有可能出现线程id相同的情况，就会导致value相同，从而错误的释放了别人的锁。

解决方案

让每个启动的服务都有一个不同的标识，再拼接线程id，就可以解决这个问题。

最终方案

  1. 在获取锁时存入线程标识（可以用UUID + 线程id 表示）

  2. 在释放锁时先获取锁中的线程标识，判断是否与当前线程标识一致

    • 如果一致则释放锁

    • 如果不一致则不释放锁

第二版代码

package cn.sticki.common.redis.utils;

import org.springframework.data.redis.core.StringRedisTemplate;

import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * @author 阿杆
 * @version 1.0
 * @date 2022/6/21 21:57
 */
public class RedisSimpleLock implements ILock {

	private final StringRedisTemplate stringRedisTemplate;

	private final String name;

	private final static String KEY_PREFIX = "lock:";

	private final static String KEY_UUID = UUID.randomUUID() + ":";

	public RedisSimpleLock(StringRedisTemplate stringRedisTemplate, String name) {
		this.stringRedisTemplate = stringRedisTemplate;
		this.name = name;
	}

	@Override
	public boolean tryLock(long timeout) {
		// 1. 生成key，通过拼接前缀和业务名
		String key = KEY_PREFIX + name;
		// 2. 生成value，用于判断该锁是不是当前线程生成的。使用随机的UUID+当前线程id，防止集群时value碰撞。
		String value = KEY_UUID + Thread.currentThread().getId();
		// 3. 尝试写入redis
		Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(key, value, timeout, TimeUnit.SECONDS);
		// 4. 返回写入情况，成功即获取到锁
		return Boolean.TRUE.equals(success);
	}

	@Override
	public void unlock() {
		String key = KEY_PREFIX + name;
		String value = KEY_UUID + Thread.currentThread().getId();
		// 1. 获取锁的值
		String lockValue = stringRedisTemplate.opsForValue().get(key);
		if (value.equals(lockValue)) {
			// 2. 若值相同，则当前锁是由当前线程创建的，可以删除
			stringRedisTemplate.delete(key);
		}
	}

}

新的问题

如果，我是说如果，在上面的unlock()代码中，获取到锁的值之后，删除key之前，发生了阻塞（GC阻塞），等阻塞完成后，当前线程创建的锁已经被释放了，然后发生了和上面类似的问题，也一样会导致锁的失效。

可能描述的不太清楚，看看示意图吧：

image-20220622112732353

解决思路

产生这个问题的原因主要在于判断锁标识和释放锁是分别执行的两个操作，解决这个问题，可以通过Lua脚本将两个操作绑定在一起。

Redis的Lua脚本

Redis提供了Lua脚本功能，在一个脚本中编写多条Redis命令，确保多条命令执行时的原子性。Lua是一种编程语言，它的基本语法可以参考网站：https://www.runoob.com/lua/lua-tutorial.html

这里重点介绍Redis提供的调用函数，语法如下：

# 执行redis命令
redis.call('命令名称', 'key', '其它参数', ...)

例如，我们要执行set name jack，则脚本是这样：

# 执行 set name jack
redis.call('set', 'name', 'jack')

例如，我们要先执行set name Rose，再执行get name，则脚本如下：

# 先执行 set name jack
redis.call('set', 'name', 'jack')
# 再执行 get name
local name = redis.call('get', 'name')
# 返回
return name

第三版代码

用Lua写释放锁

释放锁的业务流程是这样的：

  1. 获取锁中的线程标示
  2. 判断是否与指定的标示（当前线程标示）一致
  3. 如果一致则释放锁（删除）
  4. 如果不一致则什么都不做

unlock.lua（这个文件放在mian/resource下面）

-- 这里的 KEYS[1] 就是锁的key，这里的ARGV[1] 就是当前线程标示
-- 获取锁中的标示，判断是否与当前线程标示一致
if (redis.call('GET', KEYS[1]) == ARGV[1]) then
  -- 一致，则删除锁
  return redis.call('DEL', KEYS[1])
end
-- 不一致，则直接返回
return 0

Java代码如下

package cn.sticki.common.redis.utils;

import org.springframework.core.io.ClassPathResource;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;

import java.util.Collections;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

/**
 * @author 阿杆
 * @version 1.0
 * @date 2022/6/21 21:57
 */
public class RedisSimpleLock implements ILock {

	private final static String KEY_PREFIX = "lock:";

	private final static String KEY_UUID = UUID.randomUUID() + ":";

	private static final DefaultRedisScript<Long> UNLOCK_SCRIPT;

	static {
		// 加载lua文件
		UNLOCK_SCRIPT = new DefaultRedisScript<>();
		UNLOCK_SCRIPT.setLocation(new ClassPathResource("unlock.lua"));
		UNLOCK_SCRIPT.setResultType(Long.class);
	}

	private final StringRedisTemplate stringRedisTemplate;

	private final String name;

	public RedisSimpleLock(StringRedisTemplate stringRedisTemplate, String name) {
		this.stringRedisTemplate = stringRedisTemplate;
		this.name = name;
	}

	@Override
	public boolean tryLock(long timeout) {
		// 1. 生成key，通过拼接前缀和业务名
		String key = KEY_PREFIX + name;
		// 2. 生成value，用于判断该锁是不是当前线程生成的。使用随机的UUID+当前线程id，防止集群时value碰撞。
		String value = KEY_UUID + Thread.currentThread().getId();
		// 3. 尝试写入redis
		Boolean success = stringRedisTemplate.opsForValue().setIfAbsent(key, value, timeout, TimeUnit.SECONDS);
		// 4. 返回写入情况，成功即获取到锁
		return Boolean.TRUE.equals(success);
	}

	@Override
	public void unlock() {
		String key = KEY_PREFIX + name;
		String value = KEY_UUID + Thread.currentThread().getId();
		// 调用lua脚本
		stringRedisTemplate.execute(
				UNLOCK_SCRIPT,
				Collections.singletonList(key),
				value);
	}

}

总结

实现思路：

  1. 利用set nx ex获取锁，并设置过期时间，保存线程标示
  2. 释放锁时先判断线程标示是否与自己一致，一致则删除锁
  3. 利用set nx满足互斥性
  4. 利用set ex保证故障时锁依然能释放，避免死锁，提高安全性
  5. 利用Redis集群保证高可用和高并发特性

可改进点：

  1. 不可重入：同一个线程无法多次获取同一把锁
  2. 不可重试：获取锁只尝试一次就返回false，没有重试机制
  3. 超时释放：锁超时释放虽然可以避免死锁，但如果是业务执行耗时较长，也会导致锁释放，存在安全隐患
  4. 主从一致性：如果Redis提供了主从集群，主从同步存在延迟，当主宕机时，如果从并同步主中的锁数据，则会出现锁失效

引入Redisson

Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。它不仅提供了一系列的分布式的Java常用对象，还提供了许多分布式服务，其中就包含了各种分布式锁的实现。

在这里插入图片描述

官网地址： https://redisson.org
GitHub地址： https://github.com/redisson/redisson

后记

这篇文章我是学习自黑马程序员的视频课程的时候做的总结和笔记，有兴趣的同学可以自行观看视频：https://www.bilibili.com/video/BV1cr4y1671t?p=56
在这里插入图片描述

阿杆.
关注
专栏目录
Redis 作者 Antirez 讲如何实现分布式锁？Redis 实现分布式锁天然的缺陷分析&Redis分布式锁的正确使用姿势！...
AI天才研究院
11-11 8558
Redis分布式锁基本原理采用 redis 实现分布式锁，主要是利用其单线程命令执行的特性，一般是 setnx， 只会有一个线程会执行成功，也就是只有一个线程能成功获取锁；看着很完美。然而——看看可能有什么问题？一般生产环境为了可用性，redis 会部署 master-slave + sentinel 的结构， 如：master 提供服务、slave standby 作为备份节点不提供服务， ma...
Redis——发布订阅、分布式锁
weixin_44240370的博客
12-07 635
文章目录1、Redis发布订阅(1)、使用方法(2)、工作原理2、Redis实现分布式锁(1)、单机锁(2)、分布式锁<1>、电商促销<2>、数据库乐观锁<3>、数据库悲观锁<4>、基于Redis实现分布式锁<5>、Redis高可用分布式锁 1、Redis发布订阅 Redis 发布订阅(pub/sub)是一种消息通信模式：发送者(pub)发送消息，订阅者(sub)接收消息。 Redis 客户端可以订阅任意数量的频道 (1)、使用方法 订阅频道
Redis 分布式锁终极版
J贝的博客
07-17 389
先直接上代码 ​ /** * 简单redis分布式实现 解决宕机死锁和解锁了别人的锁的问题 * Created by ljb on 2017/12/26. */ @Service("simpleLockDistributeService") public class SimpleLockDistributeService{ private static final Logger...
Redis分布式锁思路
这都是什么
02-29 341
对于线程安全问题，传统的而方案是对线程资源操作加锁。 线程锁 通常使用synchronized 或者lock关键字来进行加锁。但是这个是对于同一个jvm内存的。 分布式锁 如果在多个进程中保证任务同一时刻执行，那么这个就是分布式锁了。 分布式锁实现有很多方式,常见的有zookeeper实现，缓存实现，数据库实现。 但是这些锁都有如下的特征： 多个进程可见 互斥的，也就是在同一时刻只有一个进程获得...
redis的分布式锁设计思路
guangbo0301的博客
06-17 1097
redis的分布式锁设计思路  1.概念  我们在开发时最常用的一个是java给我们提供的基于jvm的锁，锁的获取和释放由jvm来管理，我们只需要标注synchronized就可以。   另外还有Lock，需要显式的调用锁定和解锁。这两种锁的作用范围是一个jvm进程，也就是我们的一个系统中；   在分布式系统中，一个集群内的不同主机或者不同集群同时访问共享的资源，会出现竞态条件
redis实现分布式锁思路
qq_35567428的博客
07-31 143
redis 处理socket ready 事件是单线程执行的, 也就是说redis一次只会处理一个socket, 避免了并发所带来的资源竞争问题, 可以用来实现分布式锁. 具体实现思路: 通过SETNX尝试设值(currentTimestamp + timeout), 如果设置成功, 说明类似获取锁操作成功, 失败则获锁失败. 获锁成功的线程在处理完业务之后要手动释放锁DEL key...
redis分布式锁实现思路
weixin_30919919的博客
05-05 80
转载于:https://www.cnblogs.com/kuiyeit/p/10812509.html
【Redis】Redis高级：分布式锁
qq_50675319的博客
09-20 1076
上述任务的执行时间我们可以看到，是internalLockLeaseTime / 3，那么这个internalLockLeaseTime又是多少呢？其实这里的internalLockLeaseTime和我们之前提到的看门狗过期时间是同一个时间，也就是30秒，也就是说这里任务的执行时间就是10秒之后，而每当我们执行一次任务之后，任务内部又会再次调用renewExpiration()，也就是说这段任务每隔10秒就会执行一次，刷新当前线程持有锁的有效期，模拟一个锁永不过期的效果，这个任务也就被称为"看门狗"
Redis实现分布式锁与任务队列的思路
Light
12-24 359
一, 实现思路 1.Redis实现分布式锁思路 思路很简单，主要用到的redis函数是setnx()，这个应该是实现分布式锁最主要的函数。首先是将某一任务标识名（这里用Lock:order作为标识名的例子）作为键存到redis里，并为其设个过期时间，如果是还有Lock:order请求过来，先是通过setnx()看看是否能将Lock:order插入到redis里，可以的话就返回true，不可以就...
【Redis原理机制 六】Redis分布式锁深入、改进策略及RedLock算法
MaoLin Tian's Blog
11-15 669
之前聊过Redis的分布式锁并且基于理论【Redis从入门到放弃系列 十】Redis的事务机制进行过代码实践【Redis从入门到放弃系列 十一】Redis分布式锁实战，但是其实只是对分布式锁的一个简单理解，对于其中可能的问题并没有过多讨论，甚至对于真实企业场景中的分布式锁，之前的那个也许只是个玩具，存在诸多问题 ...
分布式锁（redis\ip\database）的一些实现方式及在实际中的应用
m0_37899388的博客
08-16 316
分布式锁，在分布式架构中的锁的实现。接触到的使用情形主要分为两种情况： 一：该资源只允许一次访问，请注意，此种情况更像是一种独占，即并发情况下，只有一个线程能获取该资源，其他线程则放弃该资源。 二：该资源每次只允许一个线程访问，其他线程会不断尝试获取这个锁，直到所有线程都访问了这个资源。   1。redis实现分布式锁 在redis中设置一个锁名，和value值，再为这个锁名设置超时时间...
Redis-分布式锁
weixin_44044929的博客
06-22 171
为了保证一个方法在高并发情况下的同一时间只能被同一个线程执行，在传统单体应用单机部署的情况下，可以使用Java并发处理相关的API(如ReentrantLcok或synchronized)进行互斥控制。但是，随着业务发展的需要，原单体单机部署的系统被演化成分布式系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，为了解决这个问题就需要一种跨JVM的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题。1、处理效率提升：应用分布式锁，可以减少重复任务的执行
【redis知识点整理】 --- redis实现分布式锁需要解决的问题
nrsc
05-30 1266
本文代码对应的github地址：https://github.com/nieandsun/redis-study 文章目录1 超卖现象简单介绍 1 超卖现象简单介绍 有如下代码： @RestController public class RedisLockController { @Autowired private StringRedisTemplate stringRedisTemplate; @GetMapping("/deduct_stock") public.
Redis分布式锁逐步完善过程，最后推荐Redisson框架
qq_42240540的博客
05-25 262
为什么需要分布式锁？ 我们在单机情况下我们可以通过Synchronized或Reentrantlock来实现并发安全，但是现在分布式项目怎么保证并发安全，就要通过分布式锁。 zookeeper和redis能实现分布式锁（推荐redis） 为什么可以通过这两个组件能实现分布式锁？ 因为组件是全局的，可以对一个值的有无去判断锁。再加上redis是单线程的 小型互联网公司用下面代码做分布式锁妥妥的~ package com.heyun.stadium.module.stadium.controll
分布式锁之redis实现方案
m0_47743175的博客
11-01 826
什么是分布式锁？分布式锁的redis实现方案
redis实现分布式锁及其问题解决方式
CharmingC1的博客
09-12 1058
redis实现分布式锁及其问题解决方式
最终增强
weixin_34037977的博客
09-17 184
定义最终增强 　　@AspectJ还提供了一种最终增强类型，无论方法抛出异常还是正常退出，该增强都会得到执行，类似于异常处理机制中的finally块的作用，一般用于释放资源。 转载于:https://www.cnblogs.com/myhzb/p/7538176.html...
（四）分布式锁解决方案-Redis实现方式（Jedis实现）
mtsbv110的专栏
05-08 383
基于Redis的分布式锁 使用常用命令 SETNX SETNX key val当且仅当key不存在时，set一个key为val的字符串，返回1；若key存在，则什么都不做，返回0。 Expire expire key timeout 为key设置一个超时时间，单位为second，超过这个时间锁会自动释放，避免死锁。 Delete delete key 删除key 在使用R...
分布式锁简单入门以及三种实现方式介绍
AlbenXie的博客
10-12 607
很多小伙伴在学习Java的时候，总是感觉Java多线程在实际的业务中很少使用，以至于不会花太多的时间去学习，技术债不断累积！等到了一定程度的时候对于与Java多线程相关的东西就很难理解，今天需要探讨的东西也是一样的和Java多线程相关的！做好准备，马上开车！ 学过Java多线程的应该都知道什么是锁，没学过的也不用担心，Java中的锁可以简单的理解为多线程情况下访问临界资源的一种线程同步机制。 在学习或者使用Java的过程中进程会遇到各种各样的锁的概念：公平锁、非公平锁、自旋锁、可重入锁、偏向锁、轻量级锁
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

阿杆.

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值