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

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

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

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

相关推荐

MySQL进阶五之自动读写分离mysql-proxy

自动读写分离目前，大量现网用户的业务场景中存在读多写少、业务负载无法预测等情况，在有大量读请求的应用场景下，单个实例可能无法承受读取压力，甚至会对业务产生影响。为了实现读取能力的弹性扩展，分担数据库压...

Postgres vs MySQL_vs2022连接mysql数据库

...

3分钟短文 | Laravel SQL筛选两个日期之间的记录，怎么写?

引言今天说一个细分的需求，在模型中，或者使用laravel提供的EloquentORM功能，构造查询语句时，返回位于两个指定的日期之间的条目。应该怎么写？本文通过几个例子，为大家梳理一下。学习时...

一文由浅入深带你完全掌握MySQL的锁机制原理与应用

本文将跟大家聊聊InnoDB的锁。本文比较长，包括一条SQL是如何加锁的，一些加锁规则、如何分析和解决死锁问题等内容，建议耐心读完，肯定对大家有帮助的。为什么需要加锁呢？...

验证Mysql中联合索引的最左匹配原则

后端面试中一定是必问mysql的，在以往的面试中好几个面试官都反馈我Mysql基础不行，今天来着重复习一下自己的弱点知识。在Mysql调优中索引优化又是非常重要的方法，不管公司的大小只要后端项目中用到...

MySQL索引解析(联合索引/最左前缀/覆盖索引/索引下推)

目录1.索引基础...

你会看 MySQL 的执行计划(EXPLAIN)吗?

SQL执行太慢怎么办？我们通常会使用EXPLAIN命令来查看SQL的执行计划，然后根据执行计划找出问题所在并进行优化。用法简介...

MySQL 从入门到精通(四)之索引结构

索引概述索引(index)，是帮助MySQL高效获取数据的数据结构(有序)，在数据之外，数据库系统还维护者满足特定查询算法的数据结构，这些数据结构以某种方式引用(指向)数据,这样就可以在这些数据结构...

mysql总结——面试中最常问到的知识点

mysql作为开源数据库中的榜一大哥，一直是面试官们考察的重中之重。今天，我们来总结一下mysql的知识点，供大家复习参照，看完这些知识点，再加上一些边角细节，基本上能够应付大多mysql相关面试了（...

mysql总结——面试中最常问到的知识点(2)

首先我们回顾一下上篇内容，主要复习了索引，事务，锁，以及SQL优化的工具。本篇文章接着写后面的内容。性能优化索引优化，SQL中索引的相关优化主要有以下几个方面：最好是全匹配。如果是联合索引的话，遵循最...

MySQL基础全知全解!超详细无废话!轻松上手~

本期内容提醒：全篇2300+字,篇幅较长，可搭配饭菜一同“食”用，全篇无废话(除了这句)，干货满满，可收藏供后期反复观看。注：MySQL中语法不区分大小写，本篇中...

深入剖析 MySQL 中的锁机制原理_mysql 锁详解

在互联网软件开发领域，MySQL作为一款广泛应用的关系型数据库管理系统，其锁机制在保障数据一致性和实现并发控制方面扮演着举足轻重的角色。对于互联网软件开发人员而言，深入理解MySQL的锁机制原理...

Java 与 MySQL 性能优化:MySQL分区表设计与性能优化全解析

引言在数据库管理领域，随着数据量的不断增长，如何高效地管理和操作数据成为了一个关键问题。MySQL分区表作为一种有效的数据管理技术，能够将大型表划分为多个更小、更易管理的分区，从而提升数据库的性能和可...

MySQL基础篇:DQL数据查询操作_mysql 查

一、基础查询DQL基础查询语法SELECT字段列表FROM表名列表WHERE条件列表GROUPBY分组字段列表HAVING分组后条件列表ORDERBY排序字段列表LIMIT...

MySql:索引的基本使用_mysql索引的使用和原理

一、索引基础概念1.什么是索引？索引是数据库表的特殊数据结构（通常是B+树），用于...

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