【Redis分布式锁实现】基于 Redis 单节点保姆级教程（Spring Boot 示例）

于 2025-07-28 10:00:02 发布
收藏
点赞数
CC 4.0 BY-SA版权
文章标签： it
原文链接：https://www.cnblogs.com/sun-10387834/p/19002364

下面我将详细介绍基于 Redis 单节点实现分布式锁的原理，并提供一个完整的 Spring Boot 实现示例。

实现原理

核心机制

  1. 原子获取锁：使用 SET key unique_value NX PX milliseconds 命令

    • NX：仅当 key 不存在时设置值
    • PX：设置过期时间（毫秒）
    • unique_value：唯一标识客户端（防止误删其他客户端的锁）

  2. 安全释放锁：使用 Lua 脚本保证原子性

    /* by 01130.hk - online tools website : 01130.hk/zh/calcspeed.html */
if redis.call("get", KEYS[1]) == ARGV[1] then
    return redis.call("del", KEYS[1])
else
    return 0
end

  3. 锁续期机制：可选的看门狗（Watchdog）机制，定期延长锁的有效期

关键特性

  • 互斥性：同一时刻只有一个客户端能持有锁
  • 防死锁：自动过期机制确保锁最终释放
  • 容错性：客户端崩溃后锁会自动释放
  • 安全性：只有锁的持有者才能释放锁

Spring Boot 实现示例

1. 添加依赖 (pom.xml)

/* by 01130.hk - online tools website : 01130.hk/zh/calcspeed.html */
<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.apache.commons</groupId>
        <artifactId>commons-pool2</artifactId>
    </dependency>
</dependencies>

2. 配置 Redis (application.yml)

spring:
  redis:
    host: localhost
    port: 6379
    password: 
    lettuce:
      pool:
        max-active: 8
        max-idle: 8
        min-idle: 0
        max-wait: -1ms

3. Redis 分布式锁工具类

import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.data.redis.core.script.RedisScript;
import org.springframework.stereotype.Component;

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

@Component
public class RedisDistributedLock {

    private final RedisTemplate<String, String> redisTemplate;
    
    // 锁键前缀
    private static final String LOCK_PREFIX = "lock:";
    // 解锁Lua脚本
    private static final String UNLOCK_SCRIPT = 
        "if redis.call('get', KEYS[1]) == ARGV[1] then " +
        "   return redis.call('del', KEYS[1]) " +
        "else " +
        "   return 0 " +
        "end";
    // 续期Lua脚本
    private static final String RENEW_SCRIPT = 
        "if redis.call('get', KEYS[1]) == ARGV[1] then " +
        "   return redis.call('pexpire', KEYS[1], ARGV[2]) " +
        "else " +
        "   return 0 " +
        "end";

    public RedisDistributedLock(RedisTemplate<String, String> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    /**
     * 尝试获取分布式锁
     * 
     * @param lockKey    锁的key
     * @param requestId  请求标识（可使用UUID）
     * @param expireTime 锁的过期时间(毫秒)
     * @param waitTime   等待时间(毫秒)
     * @return 是否获取成功
     */
    public boolean tryLock(String lockKey, String requestId, long expireTime, long waitTime) {
        String fullKey = LOCK_PREFIX + lockKey;
        long end = System.currentTimeMillis() + waitTime;
        
        while (System.currentTimeMillis() < end) {
            // 尝试获取锁
            Boolean success = redisTemplate.opsForValue()
                .setIfAbsent(fullKey, requestId, expireTime, TimeUnit.MILLISECONDS);
            
            if (Boolean.TRUE.equals(success)) {
                return true;
            }
            
            // 等待随机时间后重试，避免活锁
            try {
                Thread.sleep(50 + (long) (Math.random() * 100));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return false;
            }
        }
        return false;
    }

    /**
     * 释放分布式锁
     * 
     * @param lockKey   锁的key
     * @param requestId 请求标识
     * @return 是否释放成功
     */
    public boolean unlock(String lockKey, String requestId) {
        String fullKey = LOCK_PREFIX + lockKey;
        
        // 使用Lua脚本保证原子性
        RedisScript<Long> script = new DefaultRedisScript<>(UNLOCK_SCRIPT, Long.class);
        Long result = redisTemplate.execute(script, Collections.singletonList(fullKey), requestId);
        
        return result != null && result == 1;
    }

    /**
     * 锁续期（看门狗机制）
     * 
     * @param lockKey    锁的key
     * @param requestId  请求标识
     * @param expireTime 新的过期时间(毫秒)
     * @return 是否续期成功
     */
    public boolean renewLock(String lockKey, String requestId, long expireTime) {
        String fullKey = LOCK_PREFIX + lockKey;
        
        // 使用Lua脚本保证原子性
        RedisScript<Long> script = new DefaultRedisScript<>(RENEW_SCRIPT, Long.class);
        Long result = redisTemplate.execute(script, 
            Collections.singletonList(fullKey), 
            requestId, 
            String.valueOf(expireTime));
        
        return result != null && result == 1;
    }

    /**
     * 获取锁（简化版，带自动续期）
     * 
     * @param lockKey    锁的key
     * @param expireTime 锁的过期时间(毫秒)
     * @param waitTime   等待时间(毫秒)
     * @param task       需要执行的任务
     * @return 任务执行结果
     */
    public <T> T lockAndExecute(String lockKey, long expireTime, long waitTime, LockTask<T> task) {
        String requestId = UUID.randomUUID().toString();
        boolean locked = false;
        
        try {
            // 尝试获取锁
            locked = tryLock(lockKey, requestId, expireTime, waitTime);
            
            if (!locked) {
                throw new RuntimeException("获取分布式锁失败");
            }
            
            // 启动看门狗线程定期续期
            WatchDog watchDog = new WatchDog(lockKey, requestId, expireTime);
            watchDog.start();
            
            try {
                // 执行业务逻辑
                return task.execute();
            } finally {
                // 停止看门狗
                watchDog.stop();
            }
        } finally {
            // 确保锁被释放
            if (locked) {
                unlock(lockKey, requestId);
            }
        }
    }

    // 看门狗线程实现
    private class WatchDog {
        private final String lockKey;
        private final String requestId;
        private final long expireTime;
        private volatile boolean running = true;
        private Thread thread;

        public WatchDog(String lockKey, String requestId, long expireTime) {
            this.lockKey = lockKey;
            this.requestId = requestId;
            this.expireTime = expireTime;
        }

        public void start() {
            thread = new Thread(() -> {
                // 在过期时间的1/3时进行续期
                long sleepTime = expireTime / 3;
                
                while (running) {
                    try {
                        Thread.sleep(sleepTime);
                        if (!renewLock(lockKey, requestId, expireTime)) {
                            // 续期失败，可能是锁已被释放或过期
                            break;
                        }
                    } catch (InterruptedException e) {
                        Thread.currentThread().interrupt();
                        break;
                    }
                }
            }, "RedisLock-WatchDog");
            thread.setDaemon(true);
            thread.start();
        }

        public void stop() {
            running = false;
            if (thread != null) {
                thread.interrupt();
            }
        }
    }

    // 锁任务接口
    @FunctionalInterface
    public interface LockTask<T> {
        T execute();
    }
}

4. 业务服务中使用分布式锁

import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final RedisDistributedLock redisLock;
    
    public OrderService(RedisDistributedLock redisLock) {
        this.redisLock = redisLock;
    }
    
    /**
     * 创建订单（使用分布式锁保护）
     */
    public void createOrder(String orderId) {
        // 使用锁执行关键操作
        redisLock.lockAndExecute("order_create:" + orderId, 30000, 5000, () -> {
            // 在这里执行需要加锁的业务逻辑
            try {
                // 1. 检查订单是否已存在
                if (checkOrderExists(orderId)) {
                    throw new RuntimeException("订单已存在");
                }
                
                // 2. 执行创建订单的核心业务
                processOrderCreation(orderId);
                
                // 3. 记录订单日志
                logOrderCreation(orderId);
                
                return null;
            } catch (Exception e) {
                throw new RuntimeException("订单创建失败", e);
            }
        });
    }
    
    private boolean checkOrderExists(String orderId) {
        // 实际业务逻辑
        return false;
    }
    
    private void processOrderCreation(String orderId) {
        // 实际业务逻辑
        System.out.println("处理订单创建: " + orderId);
        // 模拟耗时操作
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
    
    private void logOrderCreation(String orderId) {
        // 实际业务逻辑
        System.out.println("记录订单日志: " + orderId);
    }
}

5. 控制器示例

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class OrderController {

    private final OrderService orderService;

    public OrderController(OrderService orderService) {
        this.orderService = orderService;
    }

    @GetMapping("/order/{orderId}")
    public String createOrder(@PathVariable String orderId) {
        try {
            orderService.createOrder(orderId);
            return "订单创建成功: " + orderId;
        } catch (Exception e) {
            return "订单创建失败: " + e.getMessage();
        }
    }
}

关键注意事项

  1. 锁过期时间：

    • 设置合理的时间（略大于业务执行时间）
    • 过短：业务未完成锁已释放 → 数据不一致
    • 过长：客户端崩溃后锁释放延迟 → 系统可用性降低

  2. 唯一标识（requestId）：

    • 必须保证全局唯一（使用UUID）
    • 确保只有锁的持有者才能释放锁

  3. 看门狗机制：

    • 解决业务执行时间超过锁过期时间的问题
    • 定期续期（建议在1/3过期时间时续期）
    • 业务完成后立即停止看门狗

  4. 异常处理：

    • 使用try-finally确保锁最终被释放
    • 避免因异常导致锁无法释放

  5. 重试机制：

    • 设置合理的等待时间和重试策略
    • 使用随机退避避免活锁

潜在缺陷及解决方案

缺陷解决方案
锁提前过期实现看门狗续期机制
非原子操作风险使用Lua脚本保证原子性
单点故障主从复制（但有数据丢失风险）或改用RedLock
GC暂停导致锁失效优化JVM参数，减少GC暂停时间
时钟漂移问题使用NTP同步时间，监控时钟差异
锁被误删使用唯一标识验证锁持有者

最佳实践建议

  1. 锁粒度：尽量使用细粒度锁（如订单ID而非整个系统锁）
  2. 超时设置：根据业务压力动态调整锁超时时间
  3. 监控报警：监控锁等待时间、获取失败率等关键指标
  4. 熔断机制：当Redis不可用时提供降级方案
  5. 压力测试：模拟高并发场景验证锁的正确性
  6. 避免长时间持锁：优化业务逻辑减少锁持有时间

这个实现提供了生产环境中使用Redis分布式锁的完整解决方案，包含了基本的锁获取/释放、看门狗续期机制、以及易用的API封装。在实际使用中，可以根据具体业务需求调整参数和实现细节。

cmdos
关注
详解Redis分布式锁（图文并茂，手把手搭建服务，代码详解，建议收藏）
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
07-11 1829
本文章涉及很多关联篇，如需要请自取 VMware安装CentOS（保姆级教程，建议收藏） VMware+CentOS 7 静态IP设置方法 —保姆级教程，建议收藏 CentOS 7关闭防火墙 CentOS安装单击Redis Redis一主二从Sentinel监控配置（保姆级教程） 一、简介 分布式知识是考验一个程序员知识面广度和深度很好的度量标准，而分布式锁又是其中非常重要的一个知识点。可以说面试只要谈到分布式，没有不问分布式锁的。 我们知道分布式应用在进行逻辑处理的时候经常涉及到并发.
Redis 全面指南-掌握每一个细节
weixin_67796933的博客
09-23 1401
本篇博客深入探索 Redis 的全部知识点，从基本概念到高级功能，提供全面理解这款强大的内存数据存储系统的指导。内容涵盖 Redis 的数据结构、命令用法、持久化机制、性能优化以及集群配置等关键主题。通过具体示例和最佳实践，掌握 Redis 的基本操作并学习如何构建高效的集群架构。
从零到百万级并发：SpringBoot+Redis分布式锁实战演进之路
梵心白莲的博客
04-30 969
分布式锁是一种在分布式系统环境下用于控制多个进程或线程对共享资源进行互斥访问的机制。与传统的单机锁不同，分布式锁需要考虑多个节点之间的协调和同步。
SpringBoot定时任务全解析：@Scheduled与分布式锁的深度结合
梵心白莲的博客
05-29 810
在现代的软件开发中，定时任务是一种常见的需求。例如，每天凌晨对数据进行备份、每小时统计系统的业务指标等。Spring Boot 为我们提供了方便的定时任务解决方案，即 `@Scheduled` 注解。然而，在分布式系统中，多个节点同时执行定时任务可能会导致数据不一致等问题，这时就需要引入分布式锁来保证任务的正确执行。本文将深入解析 Spring Boot 中 `@Scheduled` 注解的使用，并详细介绍如何将其与分布式锁深度结合。
SpringBoot缓存机制深入剖析：Redis与EhCache实战
梵心白莲的博客
05-23 853
缓存是一种数据临时存储机制，它可以将经常访问的数据存储在高速存储介质中，当再次需要访问这些数据时，直接从缓存中获取，而不需要再次从原始数据源（如数据库）中获取，从而显著提高系统的响应速度和性能。在高并发场景下，缓存还可以减轻数据库的压力，避免数据库因频繁的读写操作而成为系统瓶颈。
[特殊字符]【Redis 从入门到精通】保姆级教程：核心功能、Java实战、场景分析与避坑指南 | 缓存、分布式锁、消息队列一网打尽！
WD1213484的博客
05-27 1164
摘要： 本文全面介绍Redis的核心功能与实战应用，涵盖其高速缓存、分布式锁、消息队列等核心能力。文章从Redis的基本特性入手，详细解析其五种核心数据类型（String、Hash、List、Set、Sorted Set）的应用场景，并对比Java端常用客户端Jedis和Lettuce的实战操作。此外，还针对缓存击穿、雪崩等常见问题提供解决方案，帮助开发者高效利用Redis构建高性能分布式系统。适合从入门到进阶的开发者系统学习Redis技术栈。
SpringBoot缓存技术选型：Redis、Caffeine性能对比测试
梵心白莲的博客
05-30 954
在当今的应用开发中，缓存技术对于提升系统性能、降低数据库负载起着至关重要的作用。在Spring Boot应用中，合理选择缓存技术能显著提升应用的响应速度和吞吐量。Redis和Caffeine是两种在Spring Boot中广泛使用的缓存技术，它们各有特点。本文将深入探讨这两种缓存技术，并通过性能对比测试，为开发者在技术选型时提供参考。
保姆级，手把手教你物理机搭建Redis-sentinel(哨兵)集群
qq_36851486的博客
09-12 2173
手把手教你物理机搭建Redis-sentinel(哨兵)集群
Spring + Boot + Cloud + JDK8 + Elasticsearch 单节点 模式下实现全文检索高亮-分页显示 快速入门案例
流水悠然，任山川引路。
08-22 3834
JDK8+Elasticsearch单节点模式下实现全文检索高亮分页显示案例。
Spring Boot 集成 Redis：从入门到实战的详细学习指南
03-25 1108
例如，在电商网站中，商品详情页的访问量非常高，将商品信息缓存在 Redis 中，可以快速响应用户的请求，避免频繁查询数据库。Spring Boot 提供了丰富的 Starter POMs，这些 Starter POMs 包含了开发特定功能所需的依赖，开发者只需添加对应的 Starter POM，即可快速引入所需的依赖。需要注意的是，Redis 默认提供了 16 个数据库（从 0 到 15），但在实际开发中，通常不建议使用不同的数据库索引来分隔数据，而是通过不同的实例或 Redis 集群来隔离数据。
要看就看最好，16万字全网最硬核redis总结，谁赞成，谁反对？（被粉丝疯狂催更，已有人反馈看完专栏拿到大厂offer！！！）
热门推荐
Java框架、并发编程、分布式、微服务、Redis、HarmonyOS、中间件等技术
10-10 1万+
被粉丝疯狂催更，已有人反馈看完专栏拿到大厂offer，非常适合应届毕业生和初中级工程师！！！
2024年Java学习路线【超详细超实用】
m0_47946173的博客
01-29 5699
JavaSE> 贪吃蛇游戏-->多线程下载器-->图书管理系统-->在线聊天项目-->MySQL-->JDBC -->前端必修课-->Vue--> JavaWeb -->Ajax -->Maven入门篇-->Maven进阶篇-->MyBatis-->Spring-->SpringMVC-> Linux--> - > Git-->SpringBoot3 -->Redis7 -->Spring Security--> MyBatis Plus-->动力云客-->动力恒合仓储项目 --> RabbitMQ--
2022 Java面试题
qq_44785726的博客
02-18 1万+
Java面向对象有哪些特征，如何应用 ​ 面向对象编程是利用类和对象编程的一种思想。万物可归类，类是对于世界事物的高度抽象 ，不同的事物之间有不同的关系 ，一个类自身与外界的封装关系，一个父类和子类的继承关系， 一个类和多个类的多态关系。万物皆对象，对象是具体的世界事物，面向对象的三大特征封装，继承，多态。封装，封装说明一个类行为和属性与其他类的关系，低耦合，高内聚；继承是父类和子类的关系，多态说的是类与类的关系。 ​ 封装隐藏了类的内部实现机制，可以在不影响使用的情况下改变类的内部结构，同时也保护了数
练习W09-2Excel表格复制到Word的3种方法(1).pptx
07-28
练习W09-2Excel表格复制到Word的3种方法(1).pptx
python 员工管理系统，支持添加删除更新查找遍历.zip
最新发布
07-28
python 员工管理系统，支持添加删除更新查找遍历
用EXCEL制作模拟考试系统(1).doc
07-28
用EXCEL制作模拟考试系统(1).doc
网站制作开发方案书(1).doc
07-28
网站制作开发方案书(1).doc
基于物联网技术的智能家居系统毕业设计论文(1).docx
07-28
基于物联网技术的智能家居系统毕业设计论文(1).docx
springboot基于JavaWeb的物资管理系统的设计与实现-56dxwc7r.zip
07-28
springboot基于JavaWeb的物资管理系统的设计与实现-56dxwc7r.zip
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值