【Spring Boot】运用AOP来实现分布式锁

于 2024-08-09 21:07:19 发布
阅读量1k 收藏 86
点赞数 85
文章标签： spring boot 分布式 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/smile_sundays/article/details/140898706
版权

目录


如何实现一个分布式锁
本篇内容主要介绍如何使用 Java 语言实现一个注解式的分布式锁，主要是通过注解+AOP 环绕通知来实现。

一、 锁注解

我们首先写一个锁的注解

expiredTime 是设置锁的过期时间，timeoutForLock 是设置等待锁的超时时间。如果没有等待获得锁的超时时间这个功能，那么其他线程在获取锁失败时只能直接失败，无法进行排队等待。

/**
 * 分布式锁注解
 */
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD})
@Documented
public @interface RedisLock {
 
	long DEFAULT_TIMEOUT_FOR_LOCK = 5L;
	long DEFAULT_EXPIRE_TIME = 60L;
 
	String key() default "your-biz-key";
 
	long expiredTime() default DEFAULT_EXPIRE_TIME;
 
	long timeoutForLock() default DEFAULT_TIMEOUT_FOR_LOCK;
 
}

我们如何使用这个注解呢，很容易，在需要加锁的业务方法上直接用就行.如下，我们有一个库存服务类，它有一个扣减库存方法，该方法将数据库中的一个库存商品的数量减一。在并发场景下，如果我们没有对其进行资源控制，必然会发生库存扣减不一致现象。

public class StockServiceImpl {
	@RedisLock(key = "stock-lock", expiredTime = 10L, timeoutForLock = 5L)
	public void deduct(Long stockId) {
		Stock stock = this.getById(1L);
		Integer count = stock.getCount();
		stock.setCount(count - 1);
		this.updateById(stock);
	}
}

二、 在 AOP 中加锁处理

我们需要使用 AOP 来处理什么？自然是处理使用@RedisLock的方法，因此我们写一个切点表达式，它匹配所有标有 @RedisLock 注解的方法。

接着，我们将此切点表达式与 @Around 注解结合使用，以创建环绕通知，在目标方法执行前后执行我们的加锁解锁逻辑。

因此，基本的逻辑我们就理清了，代码大致长下面这个样子:

public class RedisLockAspect {
 
	private final RedisTemplate<String, Object> redisTemplate;
 
	// 锁的redis key前缀
	private static final String DEFAULT_KEY_PREFIX = "lock:";
 
	// 匹配所有标有 @RedisLock 注解的方法
	@Pointcut("@annotation(com.kelton.lock.annotation.RedisLock)")
	public void lockAnno() {
	}
 
 
	@Around("lockAnno()")
	public void invoke(ProceedingJoinPoint joinPoint) throws Exception {
		// 获取拦截方法上的RedisLock注解
		RedisLock annotation = getLockAnnotationOnMethod(joinPoint);
		// 获取锁key
		String key = getKey(annotation);
		// 锁过期时间
		long expireTime = annotation.expiredTime();
		// 获取锁的等待时间
		long timeoutForLock = annotation.timeoutForLock();
		// 在这里加锁
		someCodeForLock...
		// 执行业务
		joinPoint.proceed();
		// 在这里解锁
		someCodeForUnLock...
	}

我们在加锁的时候，需要用上 timeoutForLock 这个属性，我们通过自旋加线程休眠的方式，来达到在一段时间内等待获取锁的目的。如果自旋时间结束后，还没获取锁，则抛出异常，这里可以根据自己情况而定。自旋加锁代码如下：

// 自旋获取锁
long endTime = System.currentTimeMillis() + timeoutForLock * 1000;
boolean acquired = false;
String uuid = UUID.randomUUID().toString();
while(System.currentTimeMillis() < endTime) {
    Boolean absent = redisTemplate.opsForValue()
            .setIfAbsent(key, uuid, expireTime, TimeUnit.SECONDS);
 
    if (Boolean.TRUE.equals(absent)) {
        acquired = true;
        break;
    } else {
        // 获取不到锁，尝试休眠100毫秒后重试
        Thread.sleep(100);
    }
}
// 超时未获取到锁， 抛出异常，可根据自己业务而定
if (!acquired) {
    throw new RuntimeException("获取锁异常");
}

我们发现上面加锁的时候设置了一个 uuid 作为 value 值，这是为了在锁释放的时候，不误删其他线程上的锁，随后，我们就可以执行被 AOP 切中的方法，执行结束释放锁。代码如下：

try {
    // 执行业务
    joinPoint.proceed();
} catch (Throwable e) {
    log.error("业务执行出错！");
} finally {
    // 解锁时进行校验，只删除自己线程加的锁
    String value = (String) redisTemplate.opsForValue().get(key);
    if (uuid.equals(value)) {
        redisTemplate.delete(key);
    } else {
        log.warn("锁已过期！");
    }
}

到这里，我们就以注解+AOP 的方式实现了分布式锁的功能。当然，以上只实现了分布式锁的简单功能，还缺少了分布式锁的 key 自动续约防止锁过期功能，以及锁重入功能。

目前，RedisLockAspect的完整代码如下：

@Component
@Aspect
@Slf4j
@AllArgsConstructor
public class RedisLockAspect {
 
	// 匹配所有标有 @RedisLock 注解的方法
	@Pointcut("@annotation(com.kelton.lock.annotation.RedisLock)")
	public void lockAnno() {
	}
 
 
	@Around("lockAnno()")
	public void invoke(ProceedingJoinPoint joinPoint) throws Exception {
		// 获取拦截方法上的RedisLock注解
		RedisLock annotation = getLockAnnotationOnMethod(joinPoint);
 
		String key = getKey(annotation);
		// 锁过期时间
		long expireTime = annotation.expiredTime();
		// 获取锁的等待时间
		long timeoutForLock = annotation.timeoutForLock();
		// 自旋获取锁
		long endTime = System.currentTimeMillis() + timeoutForLock * 1000;
		boolean acquired = false;
		String uuid = UUID.randomUUID().toString();
		while(System.currentTimeMillis() < endTime) {
			Boolean absent = redisTemplate.opsForValue()
					.setIfAbsent(key, uuid, expireTime, TimeUnit.SECONDS);
 
			if (Boolean.TRUE.equals(absent)) {
				acquired = true;
				break;
			} else {
				// 获取不到锁，尝试休眠100毫秒后重试
				Thread.sleep(100);
			}
		}
		// 超时未获取到锁， 抛出异常，可根据自己业务而定
		if (!acquired) {
			throw new RuntimeException("获取锁异常");
		}
		try {
			// 执行业务
			joinPoint.proceed();
		} catch (Throwable e) {
			log.error("业务执行出错！");
		} finally {
			// 解锁时进行校验，只删除自己线程加的锁
			String value = (String) redisTemplate.opsForValue().get(key);
			if (uuid.equals(value)) {
				redisTemplate.delete(key);
			} else {
				log.warn("锁已过期！");
			}
		}
	}
 
	private String getKey(RedisLock redisLock) {
		if (Objects.isNull(redisLock)) {
			return DEFAULT_KEY_PREFIX + "default";
		}
		return DEFAULT_KEY_PREFIX + redisLock.key();
	}
 
	private RedisLock getLockAnnotationOnMethod(ProceedingJoinPoint joinPoint) {
		MethodSignature signature = (MethodSignature) joinPoint.getSignature();
		Method method = signature.getMethod();
		return method.getAnnotation(RedisLock.class);
	}
 
}

三、 key 自动续约防止锁过期

我们接着完善该分布式锁，为其添加 key 自动续约防止锁过期的功能。我们的思路与Redission的watch dog类似，开启一个后台线程，来定时检查需要续约的锁。

我们如何判断一个锁是否需要续约呢，我们可以简单定义一个续约分界线，比如在锁过期时间的三分之二的时间点及之后，对锁进行续约。

3.1 定义一个续约任务

我们来定义一个锁续约任务，那我们需要什么信息呢？

我们至少需要锁的 key，锁要设置的过期时间。这是两个最基本的信息。

要判断在锁过期时间的三分之二的时间点及之后进行续约，那么我们还需要记录锁上次续约的时间点。

此外，我们还可以为锁续约任务添加最大续约次数限制，这可以避免某些执行时间特别久的任务不断占用锁。

所以我们还需要记录当前锁续约次数和最大续约次数。

对超过最大续约次数的锁的线程，我们直接将其停止，因此我们也记录一下该锁的线程。

结合上面的分析，我们定义的锁续约任务类如下：

public class LockRenewTask {
 
	/**
	 * key
	 */
	private final String key;
	/**
	 * 过期时间。单位：秒
	 */
	private final long expiredTime;
	/**
	 * 锁的最大续约次数
	 */
	private final int maxRenewCount;
	/**
	 * 锁的当前续约次数
	 */
	private int currentRenewCount;
	/**
	 * 最新更新时间
	 */
	private LocalDateTime latestRenewTime;
	/**
	 * 业务线程
	 */
	private final Thread thread;
 
	public LockRenewTask(String key, long expiredTime, int maxRenewCount, Thread thread) {
		this.key = key;
		this.expiredTime = expiredTime;
		this.maxRenewCount = maxRenewCount;
		this.thread = thread;
		this.latestRenewTime = LocalDateTime.now();
	}
	/**
	 * 是否到达续约时间
	 * @return
	 */
	public boolean isTimeToRenew() {
		LocalDateTime now = LocalDateTime.now();
		Duration duration = Duration.between(latestRenewTime, now);
 
		return duration.toSeconds() >= ((double)(this.expiredTime / 3) * 2);
	}
	/**
	 * 是否达到最大续约次数
	 * @return
	 */
	public boolean exceedMaxRenewCount() {
		return this.currentRenewCount >= this.maxRenewCount;
	}
	public synchronized void renew() {
		this.currentRenewCount++;
		this.latestRenewTime = LocalDateTime.now();
	}
	// 取消业务方法
	public void cancel() {
		thread.interrupt();
	}
	public String getKey() {
		return key;
	}
	public long getExpiredTime() {
		return expiredTime;
	}
}
  • isTimeToRenew(): 判断是否可以对锁进行续约
  • exceedMaxRenewCount(): 判断是否达到最大续约次数
  • renew(): 来标记一次续约操作
  • cancel(): 取消业务方法

3.2 定义一个锁续约任务处理器

接着，我们定义一个定时执行该续约任务的 handler。

该 handler 也比较简答，核心逻辑是持有一个类型为 List的 taskList 来添加续约任务，且使用一个 ScheduledExecutorService 来定时遍历该 taskList 来执行续约任务。该 handler 再对外暴露一个 addRenewTask 方法，方便外部调用来添加续约任务到 taskList 中。

@Slf4j
@Component
public class LockRenewHandler {
 
	@Autowired
	private RedisTemplate<String, Object> redisTemplate;
 
	/**
	 * 保障对 taskList的添加删除操作是线程安全的
	 */
	private final ReentrantLock taskListLock = new ReentrantLock();
 
	private final List<LockRenewTask> taskList = new ArrayList<>();
 
	private final ScheduledExecutorService taskExecutorService;
 
	{
		taskExecutorService = Executors.newScheduledThreadPool(Runtime.getRuntime().availableProcessors());
		taskExecutorService.scheduleAtFixedRate(() -> {
			try {
				executeRenewTask();
			} catch (Exception e) {
				//错误处理
			}
		}, 1, 2, TimeUnit.SECONDS);
 
	}
	/**
	 * 添加续约任务
	 */
	public void addRenewTask(LockRenewTask task) {
		taskListLock.lock();
		try {
			taskList.add(task);
		} finally {
			taskListLock.unlock();
		}
	}
	/**
	 * 执行续约任务
	 */
	private void executeRenewTask() {
		log.info("开始执行续约任务");
		if (CollectionUtils.isEmpty(taskList)) {
			return;
		}
		// 需要删除的任务，暂存这个集合中  取消
		List<LockRenewTask> cancelTask = new ArrayList<>();
		// 获取任务副本
		List<LockRenewTask> copyTaskList = new ArrayList<>(taskList);
		for (LockRenewTask task : copyTaskList) {
			try {
				// 判断 Redis 中是否存在 key
				if (!redisTemplate.hasKey(task.getKey())) {
					cancelTask.add(task);
					continue;
				}
				// 大于等于最大续约次数
				if (task.exceedMaxRenewCount()) {
					// 停止续约任务
					task.cancel();
					cancelTask.add(task);
					continue;
				}
				// 到达续约时间
				if (task.isTimeToRenew()) {
					log.info("续约任务：{}", task.getKey());
					redisTemplate.expire(task.getKey(), task.getExpiredTime(), TimeUnit.SECONDS);
					task.renew();
				}
			} catch (Exception e) {
				//错误处理
				log.error("处理任务出错：{}", task);
			}
		}
		// 加锁，删除 taskList 中需要移除的任务
		taskListLock.lock();
		try {
			taskList.removeAll(cancelTask);
			// 清理cancelTask,避免堆积，产生内存泄露
			cancelTask.clear();
		} finally {
			taskListLock.unlock();
		}
	}
}

总结一下 LockRenewHandler的主要作用：它负责管理和执行续约任务，以延长 Redis 中键的过期时间。

  1. 添加续约任务：addRenewTask() 方法允许添加新的续约任务到内部列表 taskList 中。
  2. 执行续约任务：executeRenewTask() 方法定期执行续约任务。它检查每个任务的状态，并根据需要续约 Redis 中的键。
  3. 移除完成的任务：维护一个 cancelTask 列表，用于存储需要从 taskList 中移除的任务。
  4. 在 executeRenewTask() 方法中，它会将完成的任务添加到 cancelTask 列表中，并在之后将其从 taskList
    中移除。

大概的工作流程如下：

  • 续约任务被添加到 taskList 中。
  • executeRenewTask() 方法定期执行，它检查每个任务的状态：
    • 如果 Redis 中不再存在该键，则取消任务。
    • 如果任务的续约次数达到上限，则取消任务。
    • 如果是时候续约了，则续约 Redis 中的键并更新任务的续约次数，记录续约时间点。
  • 完成的任务被添加到 cancelTask 列表中。
  • executeRenewTask() 方法获取 taskList 的副本，并从副本中移除 cancelTask
    中的任务，并且在完成移除任务操作后清空cancelTask。
  • 更新后的 taskList 被保存回类中。

两个需要注意的点

我们遍历taskList时拷贝了一份副本进行遍历，因为taskList是可变的，这样可以避免在遍历的时候产生并发修改问题。

cancelTask需要清理，避免产生内存泄漏。

通过这种方式，LockRenewHandler 可以确保 Redis 中的键在需要时得到续约，并自动移除完成或失败的任务。

3.3 添加锁续约任务

在上面 3.1 节和 3.2 节我们定义好了锁续约任务和处理锁续约任务的核心代码，接下来我们需要在第 2 节加锁解锁的 AOP 处理逻辑上进行一点小小的修改，主要就是在执行加锁之后，执行业务代码之前，添加上锁续约任务。修改位置如下：

public void invoke(ProceedingJoinPoint joinPoint) throws Exception {
    ... // 省略代码
    try {
        // 添加锁续约任务
        LockRenewTask task = new LockRenewTask(key, annotation.expiredTime(), annotation.maxRenew(), Thread.currentThread());
        lockRenewHandler.addRenewTask(task);
        log.info("添加续约任务, key:{}", key);
        // 执行业务
        joinPoint.proceed();
    } catch (Throwable e) {
        log.error("业务执行出错！");
    } finally {
        // 解锁时进行校验，只删除自己线程加的锁
        String value = (String) redisTemplate.opsForValue().get(key);
        if (uuid.equals(value)) {
            redisTemplate.delete(key);
        } else {
            log.warn("锁已过期！");
        }
    }
    ... // 省略代码
}

到这里，我们的分布式锁已经相当完善了，把锁自动续约的功能也加上了。当然，还没有实现锁的可重入性。

从零开始的-CodeNinja之路
关注
【Spring】Spring Boot 集成 Zookeeper 结合AOP实现分布式锁
九师兄
07-16 178
此 demo 主要演示了如何使用 Spring Boot 集成 Zookeeper 结合AOP实现分布式锁。
AOP+注解+函数式编程实现分布式锁
weixin_50679936的博客
04-08 401
AOP+注解+函数式编程实现分布式锁
一个注解完美实现分布式锁（AOP）
小杰不秃头的博客
05-03 1130
学习过Spring的小伙伴都知道AOP的强大，本文将通过Redisson结合AOP，仅需一个注解就能实现分布式锁。🍭
AOP 实现分布式锁
jcsyl_mshot的博客
12-03 779
在web项目开发过程中，经常会遇到分布式资源控制的场景，通过加锁从而保证资源访问的互斥性。本文主要介绍在没有redis情况下通过mysql进行分布式锁的实现。 场景： 线程A与线程B执行前需要判断资源R的状态，当R的状态为1时，则可以执行，当R的状态为0时，则不容许执行，且同一时刻只容许一个线程执行。线程执行时资源R状态置0，线程执行结束后R状态重新置1. 上述场景中，若不对资源R进行互斥访问，则...
如何实现一个分布式锁
最新发布
架构师小吴的博客
07-13 1393
我们来定义一个锁续约任务，那我们需要什么信息呢？我们至少需要锁的 key，锁要设置的过期时间。这是两个最基本的信息。要判断在锁过期时间的三分之二的时间点及之后进行续约，那么我们还需要记录锁上次续约的时间点。此外，我们还可以为锁续约任务添加最大续约次数限制，这可以避免某些执行时间特别久的任务不断占用锁。所以我们还需要记录当前锁续约次数和最大续约次数。对超过最大续约次数的锁的线程，我们直接将其停止，因此我们也记录一下该锁的线程。/*** key*//*** 过期时间。单位：秒。
拒绝躺平，教你使用AOP的环绕通知实现分布式锁
wdjnb的博客
12-21 356
如何在分布式环境下，像用synchronized关键字那样使用分布式锁。比如开发一个注解，叫@DistributionLock，作用于一个方法函数上，每次调方法前加锁，调完之后自动释放锁。 可以利用Spring AOP中环绕通知的特性，完全满足上面的要求。 1、Maven依赖 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-star
AOP+自定义注解+Redis实现分布式锁
小学生波波
10-29 2686
AOP+自定义注解+Redis实现分布式锁
使用Spring Boot实现分布式锁
技术研究中心
07-13 476
分布式系统中，由于多个节点并行处理任务，为了保证数据的一致性和避免资源竞争，需要一种机制来控制对共享资源的访问。分布式锁就是一种用来在分布式环境下控制并发访问的机制，确保同一时刻只有一个节点可以获取锁。通过使用Redis作为分布式锁的存储介质，我们可以在分布式环境中安全地实现对共享资源的访问控制。在Spring Boot项目中，我们可以借助Redis来实现分布式锁。大家好，我是微赚淘客系统3.0的小编，是个冬天不穿秋裤，天冷也要风度的程序猿！著作权归聚娃科技微赚淘客系统开发者团队，转载请注明出处！
Spring Boot 分布式锁的实现
程序员小乐
09-27 905
点击上方 "程序员小乐"关注,星标或置顶一起成长每天凌晨00点00分,第一时间与你相约每日英文Things in this world are tempora...
基于Spring boot的声明式和编程式分布式锁.zip
05-30
总的来说，Spring Boot提供了良好的集成能力，使得开发者可以方便地利用各种分布式锁实现来解决并发问题。无论是声明式还是编程式，理解其原理和最佳实践，都能有效提升系统的稳定性和性能。通过学习和实践本资料包...
AOP方式实现的redis分布式锁
06-12
redis分布式锁的实现： 1、利用LUA脚本，防止redis意外导致死锁。 2、基于AOP方式实现。 3、只需要在方法上声明@DistributedLock（可以是controller的方法也可以是service的公共方法）即可实现锁功能。 4、支持在@DistributedLock上动态传参，减少锁的颗粒度。
springboot基于redis分布式锁
11-06
SpringBoot基于redis的分布式锁,有word使用文档,根据文档配置即可使用
跟着我左手右手一个慢动！手把手带你掌握：Redis分布式锁-spring boot aop+自定义注解实现分布式锁~
05-29 1146
1、为什么需要 声明式的分布式锁 编程式分布式锁每次实现都要单独实现，但业务量大功能复杂时，使用编程式分布式锁无疑是痛苦的，而声明式分布式锁不同，声明式分布式锁属于无侵入式，不会影响业务逻辑的实现。 我的为什么要用：使用简单，提升开发效率 2、怎么实现 使用spring aop + 自定义注解来实现 下面来看下spring boot + 自定义注解 如何实现一个声明式的分布式锁 3、看代码 第一步、引入aop 需要 jar包 <!-- SpringBoot AOP start --> <.
Redisson之——使用Redisson通过自定义注解实现分布式锁，使用Spring AOP简化分布式锁
2401_84009929的博客
04-18 632
这份面试题几乎包含了他在一年内遇到的所有面试题以及答案，甚至包括面试中的细节对话以及语录，可谓是细节到极致，甚至简历优化和怎么投简历更容易得到面试机会也包括在内！也包括教你怎么去获得一些大厂，比如阿里，腾讯的内推名额！某位名人说过成功是靠99%的汗水和1%的机遇得到的，而你想获得那1%的机遇你首先就得付出99%的汗水！你只有朝着你的目标一步一步坚持不懈的走下去你才能有机会获得成功！成功只会留给那些有准备的人！《互联网大厂面试真题解析、进阶开发核心学习笔记、全套讲解视频、实战项目源码讲义》
springboot分布式锁
一起coding，一起嗨。
01-28 3123
一、使用redis实现分布式锁 @Autowired RedisTemplate redisTemplate; void test01() { String localKey = "lock01"; //设置当前客户端ID String clentId = UUID.randomUUID().toString(); try { //判断localKey是否存在，如果不存在，设置值，如果存在，不执行任务
SpringBoot使用分布式锁
weixin_49390750的博客
08-15 700
SpringBoot使用分布式锁
Spring Boot 中的分布式锁
it_xushixiong的博客
07-04 1712
分布式锁是一种用于保护共享资源的机制。在分布式环境中，多个应用程序可能需要同时对同一个资源进行修改，这时候就需要使用分布式锁来确保资源的一致性和完整性。分布式锁可以将资源的修改操作变成原子操作，避免了数据的不一致性和冲突等问题。常见的分布式锁实现方式有基于数据库、基于缓存、基于ZooKeeper等。在本文中，我们将介绍基于Redis实现的分布式锁。在 Redis 中，可以使用 SET key value NX EX seconds 命令来实现分布式锁的功能。SET key value：设置键值对。
springboot分布式锁实现（Redisson）
少年有事问春风
09-15 3250
springboot分布式锁实现（Redisson）+ 看门狗机制
spring-redis实现的Redis分布式锁的例子
11-21
以下是使用Spring Redis实现Redis分布式锁的例子： 首先，在pom.xml文件中添加以下依赖： ```xml <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-aop</artifactId> </dependency> ``` 然后，创建一个Redis分布式锁的接口： ```java public interface RedisLock { /** * 获取锁 * * @param key 锁的key * @param expireTime 锁的过期时间 * @return 是否获取成功 */ boolean lock(String key, long expireTime); /** * 释放锁 * * @param key 锁的key */ void unlock(String key); } ``` 接着，实现Redis分布式锁的接口： ```java @Component public class RedisLockImpl implements RedisLock { private final RedisTemplate<String, String> redisTemplate; private final ThreadLocal<Map<String, Integer>> lockers = new ThreadLocal<>(); @Autowired public RedisLockImpl(RedisTemplate<String, String> redisTemplate) { this.redisTemplate = redisTemplate; } @Override public boolean lock(String key, long expireTime) { Map<String, Integer> localLockers = getLocalLockers(); Integer count = localLockers.get(key); if (count != null) { localLockers.put(key, count + 1); return true; } Boolean result = redisTemplate.opsForValue().setIfAbsent(key, ""); if (!result) { return false; } redisTemplate.expire(key, expireTime, TimeUnit.MILLISECONDS); localLockers.put(key, 1); return true; } @Override public void unlock(String key) { Map<String, Integer> localLockers = getLocalLockers(); Integer count = localLockers.get(key); if (count == null) { return; } if (count > 1) { localLockers.put(key, count - 1); } else { localLockers.remove(key); redisTemplate.delete(key); } } private Map<String, Integer> getLocalLockers() { Map<String, Integer> localLockers = lockers.get(); if (localLockers != null) { return localLockers; } lockers.set(new HashMap<>()); return lockers.get(); } } ``` 最后，在需要使用分布式锁的地方，注入RedisLock接口，使用lock()方法获取锁，使用unlock()方法释放锁： ```java @Service public class UserService { private final RedisLock redisLock; @Autowired public UserService(RedisLock redisLock) { this.redisLock = redisLock; } public void updateUser(String userId) { String lockKey = "user_" + userId; boolean locked = redisLock.lock(lockKey, 5000); if (!locked) { throw new RuntimeException("获取锁失败"); } try { // 更新用户信息 } finally { redisLock.unlock(lockKey); } } } ```
评论 129
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

从零开始的-CodeNinja之路

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

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

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

打赏作者

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

抵扣说明：

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

余额充值