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

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

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

在互联网大厂的后端开发领域，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 脚本实现则更灵活，能满足一些对性能和原子性有极致要求的场景。各位后端开发的小伙伴们，赶紧在你们的项目中实践起来吧！要是在实现过程中有任何疑问或者新的见解，欢迎在评论区留言分享，咱们一起交流探讨，共同攻克技术难题，让我们的项目在分布式锁的保障下更加稳定、高效地运行。

相关推荐

每天一个编程技巧!掌握这7个神技，代码效率飙升200%

“同事6点下班，你却为改BUG加班到凌晨？不是你不努力，而是没掌握‘偷懒’的艺术！本文揭秘谷歌工程师私藏的7个编程神技，每天1分钟，让你的代码从‘能用’变‘逆天’。文末附《Python高效代码模板》，...

Git重置到某个历史节点(Sourcetree工具)

前言Sourcetree回滚提交和重置当前分支到此次提交的区别？回滚提交是指将改动的代码提交到本地仓库，但未推送到远端仓库的时候。...

git工作区、暂存区、本地仓库、远程仓库的区别和联系

很多程序员天天写代码，提交代码，拉取代码，对git操作非常熟练，但是对git的原理并不甚了解，借助豆包AI，写个文章总结一下。Git的四个核心区域（工作区、暂存区、本地仓库、远程仓库）是版本控制的核...

解锁人生新剧本的密钥:学会让往事退场

开篇：敦煌莫高窟的千年启示在莫高窟321窟的《降魔变》壁画前，讲解员指着斑驳色彩说："画师刻意保留了历代修补痕迹，因为真正的传承不是定格，而是流动。"就像我们的人生剧本，精彩章节永远...

Reset local repository branch to be just like remote repository HEAD

技术背景在使用Git进行版本控制时，有时会遇到本地分支与远程分支不一致的情况。可能是因为误操作、多人协作时远程分支被更新等原因。这时就需要将本地分支重置为与远程分支的...

Git恢复至之前版本（git恢复到pull之前的版本）

让程序回到提交前的样子：两种解决方法：回退（reset）、反做（revert）方法一：gitreset...

如何将文件重置或回退到特定版本（怎么让文件回到初始状态）

技术背景在使用Git进行版本控制时，经常会遇到需要将文件回退到特定版本的情况。可能是因为当前版本出现了错误，或者想要恢复到之前某个稳定的版本。Git提供了多种方式来实现这一需求。...

git如何正确回滚代码（git命令回滚代码）

方法一，删除远程分支再提交①首先两步保证当前工作区是干净的，并且和远程分支代码一致$gitcocurrentBranch$gitpullorigincurrentBranch$gi...

[git]撤销的相关命令:reset、revert、checkout

基本概念如果不清晰上面的四个概念，请查看廖老师的git教程这里我多说几句：最开始我使用git的时候，我并不明白我为什么写完代码要用git的一些列指令把我的修改存起来。后来用多了，也就明白了为什么。gi...

利用shell脚本将Mysql错误日志保存到数据库中

说明:利用shell脚本将MYSQL的错误日志提取并保存到数据库中步骤:1)创建数据库,创建表CreatedatabaseMysqlCenter;UseMysqlCenter;CREATET...

MySQL 9.3 引入增强的JavaScript支持

MySQL，这一广泛采用的开源关系型数据库管理系统（RDBMS），发布了其9.x系列的第三个更新版本——9.3版，带来了多项新功能。...

python 连接 mysql 数据库（python连接MySQL数据库案例）

用PyMySQL包来连接Python和MySQL。在使用前需要先通过pip来安装PyMySQL包：在windows系统中打开cmd,输入pipinstallPyMySQL ...

mysql导入导出命令（mysql 导入命令）

mysql导入导出命令mysqldump命令的输入是在bin目录下.1.导出整个数据库　　mysqldump-u用户名-p数据库名>导出的文件名　　mysqldump-uw...

MySQL-SQL介绍（mysql sqlyog）

介绍结构化查询语言是高级的非过程化编程语言，允许用户在高层数据结构上工作。它不要求用户指定对数据的存放方法，也不需要用户了解具体的数据存放方式，所以具有完全不同底层结构的不同数据库系统,可以使用相同...

MySQL 误删除数据恢复全攻略:基于 Binlog 的实战指南

在MySQL的世界里，二进制日志（Binlog）就是我们的"时光机"。它默默记录着数据库的每一个重要变更，就像一位忠实的史官，为我们在数据灾难中提供最后的救命稻草。本文将带您深入掌握如...

一周热门
最近发表
标签列表
Copyright Your WebSite.Some Rights Reserved.