百度360必应搜狗淘宝本站头条
mysql distinctjenkins官网mysql 子查询vba splitpython list sort
当前位置：网站首页 > IT技术 > 正文

Spring Boot3 中通过 Redis 实现分布式锁的那些事儿

wptr33 2025-03-10 21:11 21 浏览

在互联网大厂的后端开发领域，Spring Boot3 框架广泛应用于构建高效的应用程序。而随着业务规模的不断扩大，分布式系统的复杂性日益增加，如何确保多个服务实例对共享资源的安全、有序访问，成为了亟待解决的关键问题。分布式锁，作为应对这一挑战的有力手段，发挥着至关重要的作用。在众多实现分布式锁的技术方案中，借助 Redis 来实现具有显著优势，因其出色的性能和丰富的数据结构，成为了广大后端开发者的热门选择。今天，我们就深入探讨一下在 Spring Boot3 项目里，如何巧妙运用 Redis 实现分布式锁。

背景介绍

在单机应用的时代，我们使用线程锁就能轻松控制并发访问。可如今，分布式系统大行其道，多个应用实例运行在不同服务器上，传统线程锁就 “有心无力” 了。分布式锁应运而生，它的使命就是管控分布式系统里多个节点对共享资源的访问，保证同一时刻只有一个节点能拿到锁并执行相关操作，从而维护数据一致性和操作原子性。而 Redis，凭借其出色的性能和丰富的数据结构，成为实现分布式锁的绝佳选择。在众多互联网大厂的后端开发中，有相当高比例的项目会用到 Spring Boot3 框架，同时，超过半数的项目会借助 Redis 来实现分布式锁。这足以看出 Spring Boot3 和 Redis 在分布式锁实现上的 “黄金搭档” 地位。

解决方案

基于 Redisson 框架实现

引入依赖

在项目的 pom.xml 文件里，添加 Redisson 的依赖。就像这样


    org.redisson
    redisson-spring-boot-starter
    3.18.0

配置 Redis 连接

在 application.yml 文件中，配置 Redis 的连接信息。假设你的 Redis 运行在本地，端口是 6379，配置如下：

spring:
  data:
    redis:
      database: 0
      host: 127.0.0.1
      port: 6379
      password: 123456 # 如果没有密码，可去掉这一行

创建 RedisLockService 类

创建一个 RedisLockService 类，专门用来管理分布式锁的获取和释放。代码如下：

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import java.util.concurrent.TimeUnit;

@Service
public class RedisLockService {
    @Autowired
    private RedissonClient redissonClient;

    /**
     * 获取锁的方法
     * @param lockKey 锁键
     * @param waitTime 等待时间
     * @param leaseTime 租约时间
     * @return 是否获取到锁
     */
    public boolean acquireLock(String lockKey, long waitTime, long leaseTime) {
        // 获取指定锁键对应的Redisson锁
        RLock lock = redissonClient.getLock(lockKey);
        try {
            // 尝试以指定等待时间和租约时间获取锁
            return lock.tryLock(waitTime, leaseTime, TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            // 当前线程中断
            Thread.currentThread().interrupt();
            // 返回获取锁失败
            return false;
        }
    }

    /**
     * 释放锁的方法
     * @param lockKey 锁键
     */
    public void releaseLock(String lockKey) {
        // 获取指定锁键对应的Redisson锁
        RLock lock = redissonClient.getLock(lockKey);
        // 如果当前线程持有该锁
        if (lock.isHeldByCurrentThread()) {
            // 释放锁
            lock.unlock();
        }
    }
}

创建控制器测试

创建一个控制器，用来测试分布式锁的实际效果。代码如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LockController {
    @Autowired
    private RedisLockService redisLockService;

    @GetMapping("/doSomething")
    public String doSomething() {
        String lockKey = "myLock";
        boolean isLockAcquired = redisLockService.acquireLock(lockKey, 5, 10);
        if (isLockAcquired) {
            try {
                System.out.println("获取到锁！");
                // 在这里执行你的业务逻辑
                Thread.sleep(5000); // 模拟业务处理时间
                return "业务处理完成";
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return "业务处理失败";
            } finally {
                redisLockService.releaseLock(lockKey);
                System.out.println("锁已释放！");
            }
        } else {
            System.out.println("未能获取到锁！");
            return "业务处理失败";
        }
    }
}

基于 Redis Lua 脚本实现

创建工具类

创建一个 RedisLuaUtils 工具类，把加锁和解锁的逻辑封装起来。代码如下：

package com.modules.redis.utils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import java.time.Duration;
import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

@Slf4j
public class RedisLuaUtils {
    // 超时时间（毫秒）
    private static final long TIMEOUT_MILLIS = 15000;
    // 重试次数
    private static final int RETRY_TIMES = 10;
    // 睡眠时间（重试间隔）
    private static final long SLEEP_MILLIS = 100;

    // 用来加锁的lua脚本
    private static final String LOCK_LUA = "if redis.call(\"setnx\",KEYS(1),ARGV(1)) == 1 " +
            "then " +
            " return redis.call('expire',KEYS(1),ARGV(2)) " +
            "else " +
            " return 0 " +
            "end";

    // 用来释放分布式锁的lua脚本
    private static final String UNLOCK_LUA = "if redis.call(\"get\",KEYS(1)) == ARGV(1) " +
            "then " +
            " local number = redis.call(\"del\", KEYS(1)) " +
            " return tostring(number) " +
            "else " +
            " return tostring(0) " +
            "end ";

    // 检查redisKey是否上锁（没加锁返回加锁）
    public static Boolean isLock(String redisKey, String value, RedisTemplate template) {
        return lock(redisKey, value, template, RETRY_TIMES);
    }

    private static Boolean lock(String redisKey, String value, RedisTemplate template, int retryTimes) {
        boolean result = lockKey(redisKey, value, template);
        // 循环等待上一个用户锁释放，或者锁超时释放
        while (!(result) && retryTimes-- > 0) {
            try {
                log.debug("lock failed, retrying...{}", retryTimes);
                Thread.sleep(RedisLuaUtils.SLEEP_MILLIS);
            } catch (InterruptedException e) {
                return false;
            }
            result = lockKey(redisKey, value, template);
        }
        return result;
    }

    // 加锁
    private static Boolean lockKey(String redisKey, String value, RedisTemplate template) {
        DefaultRedisScript redisScript = new DefaultRedisScript<>(LOCK_LUA, Long.class);
        List keys = new CopyOnWriteArrayList<>();
        keys.add(redisKey);
        List args = new CopyOnWriteArrayList<>();
        args.add(value);
        args.add(String.valueOf(TIMEOUT_MILLIS / 1000));
        Long result = template.execute(redisScript, keys, args);
        return result!= null && result == 1;
    }

    // 解锁
    public static void unlock(String redisKey, String value, RedisTemplate template) {
        DefaultRedisScript redisScript = new DefaultRedisScript<>(UNLOCK_LUA, Long.class);
        List keys = new CopyOnWriteArrayList<>();
        keys.add(redisKey);
        List args = new CopyOnWriteArrayList<>();
        args.add(value);
        template.execute(redisScript, keys, args);
    }
}

使用工具类加锁解锁

在需要使用分布式锁的地方，注入 RedisTemplate，调用 RedisLuaUtils 工具类的方法来加锁和解锁。代码如下：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Component;

@Component
public class SomeService {
    @Autowired
    private RedisTemplate redisTemplate;

    public void doSomething() {
        String lockKey = "my_lock_key";
        String value = "unique_value";
        boolean locked = RedisLuaUtils.isLock(lockKey, value, redisTemplate);
        if (locked) {
            try {
                // 获取锁成功后执行需要加锁的代码块
                System.out.println("成功获取到锁，开始执行任务...");
                // 模拟执行任务
                Thread.sleep(10000);
                System.out.println("任务执行完成！");
            } catch (InterruptedException e) {
                // 处理线程中断异常
                Thread.currentThread().interrupt();
            } finally {
                // 释放锁
                RedisLuaUtils.unlock(lockKey, value, redisTemplate);
                System.out.println("释放锁！");
            }
        } else {
            // 获取锁失败，处理失败逻辑
            System.out.println("获取锁失败！");
        }
    }
}

总结

通过上述两种方式，我们能够在 Spring Boot3 项目中顺利地利用 Redis 实现分布式锁。Redisson 框架提供了强大且易用的 API，极大地简化了分布式锁的实现过程；而基于 Redis Lua 脚本实现则更灵活，能满足一些对性能和原子性有极致要求的场景。各位后端开发的小伙伴们，赶紧在你们的项目中实践起来吧！要是在实现过程中有任何疑问或者新的见解，欢迎在评论区留言分享，咱们一起交流探讨，共同攻克技术难题，让我们的项目在分布式锁的保障下更加稳定、高效地运行。

相关推荐

redis的八种使用场景

前言:redis是我们工作开发中，经常要打交道的，下面对redis的使用场景做总结介绍也是对redis举报的功能做梳理。缓存Redis最常见的用途是作为缓存，用于加速应用程序的响应速度。...

基于Redis的3种分布式ID生成策略

在分布式系统设计中，全局唯一ID是一个基础而关键的组件。随着业务规模扩大和系统架构向微服务演进，传统的单机自增ID已无法满足需求。高并发、高可用的分布式ID生成方案成为构建可靠分布式系统的必要条件。R...

基于OpenWrt系统路由器的模式切换与网页设计

摘要：目前商用WiFi路由器已应用到多个领域，商家通过给用户提供一个稳定免费WiFi热点达到吸引客户、提升服务的目标。传统路由器自带的Luci界面提供了工厂模式的Web界面，用户可通过该界面配置路...

这篇文章教你看明白 nginx-ingress 控制器

主机nginx一般nginx做主机反向代理（网关）有以下配置...

如何用redis实现注册中心

一句话总结使用Redis实现注册中心：服务注册...

爱可可老师24小时热门分享(2020.5.10)

No1.看自己以前写的代码是种什么体验？No2.DooM-chip!国外网友SylvainLefebvre自制的无CPU、无操作码、无指令计数器...No3.我认为CS学位可以更好，如...

Apportable:拯救程序员，IOS一秒变安卓

摘要：还在为了跨平台使用cocos2d-x吗,拯救objc程序员的奇葩来了,ApportableSDK:FreeAndroidsupportforcocos2d-iPhone。App...

JAVA实现超买超卖方案汇总，那个最适合你，一篇文章彻底讲透

以下是几种Java实现超买超卖问题的核心解决方案及代码示例，针对高并发场景下的库存扣减问题：方案一：Redis原子操作+Lua脚本（推荐）//使用Redis+Lua保证原子性publicbo...

3月26日更新 快速施法自动施法可独立设置

2016年3月26日DOTA2有一个79.6MB的更新主要是针对自动施法和快速施法的调整本来内容不多不少朋友都有自动施法和快速施法的困扰英文更新日志一些视觉BUG修复就不翻译了主要翻译自动施...

Redis 是如何提供服务的

在刚刚接触Redis的时候，最想要知道的是一个’setnameJhon’命令到达Redis服务器的时候，它是如何返回’OK’的？里面命令处理的流程如何，具体细节怎么样？你一定有问过自己...

lua _G、_VERSION使用

到这里我们已经把lua基础库中的函数介绍完了，除了函数外基础库中还有两个常量，一个是_G，另一个是_VERSION。_G是基础库本身，指向自己，这个变量很有意思，可以无限引用自己，最后得到的还是自己，...

China&#39;s top diplomat to chair third China-Pacific Island countries foreign ministers&#39; meeting

BEIJING,May21(Xinhua)--ChineseForeignMinisterWangYi,alsoamemberofthePoliticalBureau...

移动工作交流工具Lua推出Insights数据分析产品

Lua是一个适用于各种职业人士的移动交流平台，它在今天推出了一项叫做Insights的全新功能。Insights是一个数据平台，客户可以在上面实时看到员工之间的交流情况，并分析这些情况对公司发展的影响...

Redis 7新武器:用Redis Stack实现向量搜索的极限压测

当传统关系型数据库还在为向量相似度搜索的性能挣扎时，Redis7的RedisStack...

Nginx/OpenResty详解，Nginx Lua编程，重定向与内部子请求

重定向与内部子请求Nginx的rewrite指令不仅可以在Nginx内部的server、location之间进行跳转，还可以进行外部链接的重定向。通过ngx_lua模块的Lua函数除了能实现Nginx...

一周热门
最近发表
标签列表
赣ICP备2024040476号-12