Redis实现分布式锁

最新推荐文章于 2025-05-03 15:55:01 发布
最新推荐文章于 2025-05-03 15:55:01 发布
阅读量590 收藏 6
点赞数 5
文章标签： redis 分布式 数据库
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyxzyx666/article/details/147656649
版权

分布式锁是分布式系统中解决资源竞争问题的重要机制。Redis凭借其高性能和原子性操作，成为实现分布式锁的热门选择。本文将详细介绍如何使用Java和Redis实现分布式锁，并重点讲解如何通过Lua脚本保证锁操作的原子性。

一、分布式锁的基本要求

一个可靠的分布式锁应满足以下条件：

  1. 互斥性：同一时刻只有一个客户端能持有锁

  2. 避免死锁：即使客户端崩溃，锁也能自动释放

  3. 容错性：只要大部分Redis节点正常运行，客户端就能获取和释放锁

  4. 释放锁的正确性：只能由锁的持有者释放锁

二、不使用Lua脚本的基础实现

1. 基础分布式锁实现（Java + StringRedisTemplate）

import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Component;

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

@Component
public class BasicRedisLock {

    private final StringRedisTemplate stringRedisTemplate;
    
    public BasicRedisLock(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    /**
     * 获取锁
     * @param lockKey 锁的key
     * @param expireTime 过期时间(秒)
     * @return 锁的value（用于释放锁时验证）
     */
    public String lock(String lockKey, long expireTime) {
        String value = UUID.randomUUID().toString();
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(lockKey, value, expireTime, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success) ? value : null;
    }

    /**
     * 释放锁
     * @param lockKey 锁的key
     * @param value 锁的value
     * @return 是否释放成功
     */
    public boolean unlock(String lockKey, String value) {
        // 1. 获取当前锁的值
        String currentValue = stringRedisTemplate.opsForValue().get(lockKey);
        
        // 2. 验证是否是自己的锁
        if (value.equals(currentValue)) {
            // 3. 删除锁
            return stringRedisTemplate.delete(lockKey);
        }
        return false;
    }
}

2. 基础实现的使用示例

@RestController
public class OrderController {

    @Autowired
    private BasicRedisLock basicRedisLock;
    
    @PostMapping("/createOrder")
    public String createOrder() {
        String lockKey = "order_lock";
        String lockValue = null;
        
        try {
            // 尝试获取锁
            lockValue = basicRedisLock.lock(lockKey, 30);
            if (lockValue == null) {
                return "系统繁忙，请稍后再试";
            }
            
            // 执行业务逻辑
            return "订单创建成功";
        } finally {
            // 释放锁
            if (lockValue != null) {
                basicRedisLock.unlock(lockKey, lockValue);
            }
        }
    }
}

3. 基础实现的缺点

  1. 非原子性操作问题：

    • 释放锁的操作分为"获取值"、"比较值"和"删除键"三步，不是原子操作

    • 在比较值和删除键之间，锁可能已过期并被其他客户端获取，导致误删别人的锁

  2. 网络延迟问题：

    • 客户端A获取锁并执行时间过长，锁已自动释放

    • 客户端B获取了锁

    • 客户端A执行完任务后，仍会尝试释放锁，可能释放客户端B的锁

  3. 性能问题：

    • 每次释放锁需要至少2次Redis操作（GET+DEL）

三、使用Lua脚本优化实现

1. Lua脚本实现的分布式锁

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

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

@Component
public class LuaRedisLock {

    private final StringRedisTemplate stringRedisTemplate;
    
    public LuaRedisLock(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    // 获取锁（与基础实现相同）
    public String lock(String lockKey, long expireTime) {
        String value = UUID.randomUUID().toString();
        Boolean success = stringRedisTemplate.opsForValue()
                .setIfAbsent(lockKey, value, expireTime, TimeUnit.SECONDS);
        return Boolean.TRUE.equals(success) ? value : null;
    }

    // 使用Lua脚本释放锁
    public boolean unlock(String lockKey, String value) {
        // Lua脚本
        String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                          "    return redis.call('del', KEYS[1]) " +
                          "else " +
                          "    return 0 " +
                          "end";
        
        // 创建Redis脚本对象
        DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
        redisScript.setScriptText(luaScript);
        redisScript.setResultType(Long.class);
        
        // 执行脚本
        Long result = stringRedisTemplate.execute(
            redisScript, 
            Collections.singletonList(lockKey), 
            value
        );
        
        return result != null && result == 1;
    }
}

2. Lua脚本详解

Lua脚本语法说明
-- KEYS[1] 表示第一个键参数
-- ARGV[1] 表示第一个非键参数
-- redis.call() 用于执行Redis命令

-- 脚本逻辑：
if redis.call('get', KEYS[1]) == ARGV[1] then  -- 如果锁的值等于传入的值
    return redis.call('del', KEYS[1])          -- 则删除这个键
else
    return 0                                   -- 否则返回0表示失败
end
Lua脚本在Redis中的优势

  1. 原子性：整个脚本作为一个整体执行，执行期间不会被其他命令打断

  2. 减少网络开销：多个操作合并为一个脚本，减少客户端与Redis的交互次数

  3. 灵活性：可以编写复杂的逻辑来处理各种场景

3. Lua脚本实现的使用示例

@RestController
public class PaymentController {

    @Autowired
    private LuaRedisLock luaRedisLock;
    
    @PostMapping("/pay")
    public String payOrder(@RequestParam String orderId) {
        String lockKey = "pay_lock:" + orderId;
        String lockValue = null;
        
        try {
            // 尝试获取锁，设置30秒过期
            lockValue = luaRedisLock.lock(lockKey, 30);
            if (lockValue == null) {
                return "支付处理中，请勿重复提交";
            }
            
            // 执行业务逻辑
            processPayment(orderId);
            
            return "支付成功";
        } finally {
            // 释放锁
            if (lockValue != null) {
                luaRedisLock.unlock(lockKey, lockValue);
            }
        }
    }
    
    private void processPayment(String orderId) {
        // 支付处理逻辑
    }
}

四、两种实现的对比

特性基础实现Lua脚本实现
原子性非原子操作原子操作
安全性可能误删别人的锁不会误删别人的锁
网络开销至少2次Redis操作1次Redis操作
实现复杂度简单需要了解Lua脚本
性能较低较高
适用场景对安全性要求不高的简单场景对安全性和性能有要求的场景

五、Lua脚本的更多用法

1. 带重试的获取锁脚本

public String lockWithRetry(String lockKey, long expireTime, long waitTime) {
    String value = UUID.randomUUID().toString();
    
    String luaScript = "local wait = tonumber(ARGV[3]) * 1000 " +
                      "local endTime = redis.call('time')[1] * 1000 + wait " +
                      "while redis.call('time')[1] * 1000 < endTime do " +
                      "    if redis.call('setnx', KEYS[1], ARGV[1]) == 1 then " +
                      "        redis.call('expire', KEYS[1], ARGV[2]) " +
                      "        return ARGV[1] " +
                      "    end " +
                      "    -- 短暂休眠 " +
                      "    redis.call('echo', 'waiting...') " +
                      "end " +
                      "return nil";
    
    DefaultRedisScript<String> redisScript = new DefaultRedisScript<>();
    redisScript.setScriptText(luaScript);
    redisScript.setResultType(String.class);
    
    return stringRedisTemplate.execute(
        redisScript,
        Collections.singletonList(lockKey),
        value, String.valueOf(expireTime), String.valueOf(waitTime)
    );
}

2. 锁续期脚本

public boolean renewLock(String lockKey, String value, long expireTime) {
    String luaScript = "if redis.call('get', KEYS[1]) == ARGV[1] then " +
                      "    return redis.call('expire', KEYS[1], ARGV[2]) " +
                      "else " +
                      "    return 0 " +
                      "end";
    
    DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
    redisScript.setScriptText(luaScript);
    redisScript.setResultType(Long.class);
    
    Long result = stringRedisTemplate.execute(
        redisScript,
        Collections.singletonList(lockKey),
        value, String.valueOf(expireTime)
    );
    
    return result != null && result == 1;
}

六、总结

  1. 基础实现简单但存在安全隐患，适合对一致性要求不高的场景

  2. Lua脚本实现通过原子操作解决了安全问题，是生产环境推荐的做法

  3. Lua脚本在Redis中执行是原子的，适合实现复杂的多步操作

  4. 实际应用中还可以结合Redisson等成熟框架，它们提供了更完善的分布式锁实现

 

redis实现分布式锁
qq_35861084的博客
10-30 1212
通过唯一标识值和原子操作，保证了锁的基本原子性和持有者的唯一性。Watchdog 自动续期确保任务执行超时时不会因锁过期被其他线程抢占。Redisson 提供了更高的易用性和可靠性，非常适合在 Spring Boot 中集成。
C++ redis实现分布式锁
恋恋风辰的技术博客
10-11 1956
在单机环境中，常见的锁机制如互斥锁（Mutex）用于保护共享资源。然而，在分布式系统中，由于多个进程可能运行在不同的机器上，单纯依赖本地锁无法实现资源的同步访问。这就需要分布式锁来确保跨多个节点的互斥访问。分布式锁的关键特性：同一时刻只有一个客户端可以获取锁。锁有超时机制，防止因客户端故障导致的死锁。即使部分节点失效，锁机制仍然可靠。
Redis 实现分布式锁
tatasix的博客
01-03 1200
本文主要介绍了Redis的分布式锁。涉及Reids的原子操作，分布式锁，Redis的事务，以及用Go语言实现通过Lua脚本来扣减库存。
Java 使用redis实现分布式锁
weixin_45410882的博客
09-30 5047
Java SpringCloud实现分布式锁 (jedis、jedis+lua、redisson)
Redis实现分布式锁(附源码+讲义)
07-01
分布式锁有很多种解决方案，今天我们要讲的是怎么使用缓存数据库Redis来实现分布式锁。 课程目标:  理解redis分布式锁的应用场景  掌握redis分布式锁的实现原理  掌握redis分布式锁在微服务项目中的应用  掌握...
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
本文将深入探讨如何使用Redis实现分布式锁，以及如何利用自旋式加锁和Lua脚本实现原子性解锁。 首先，我们来理解分布式锁的基本概念。分布式锁是在多节点之间共享资源时，用于协调各个节点的访问控制机制。在分布式...
Java基于redis实现分布式锁代码实例
08-19
Java基于Redis实现分布式锁代码实例 分布式锁的必要性 在多线程环境中，资源竞争是一个常见的问题。例如，在一个简单的用户操作中，一个线程修改用户状态，首先在内存中读取用户状态，然后在内存中进行修改，然后...
基于redis实现分布式锁的原理与方法
12-14
redis实现分布式锁 数据库实现分布式锁 zk实现分布式锁 今天我们介绍通过redis实现分布式锁。实际上这三种和java对比看属于一类。都是属于程序外部锁。 原理剖析 上述三种分布式锁都是通过各自为依据对各个请求...
基于Redis实现-附近商铺查询
2302_77423520的博客
05-01 873
Redis GEO支持地理坐标存储与查询，提供GEOADD添加坐标、GEOSEARCH范围搜索等功能，可快速实现附近地点查询。通过Spring Data Redis可便捷集成，支持按坐标或名称搜索，灵活控制返回结果排序和内容。适用于查找周边商铺、计算距离等场景，是构建位置服务的理想方案。
深入理解Redis SDS：高性能字符串的终极设计指南
2201_75525624的博客
05-03 759
在数据库开发领域，C语言原生字符串就像一把双刃剑——虽然简单易用，但在处理高并发、大数据量时却频频暴露出内存溢出性能低下等致命问题。Redis作为每秒处理百万级请求的内存数据库，用自主设计的完美解决了这些痛点。本文将带您穿越Redis源码，拆解这个支撑起Redis高性能的核心数据结构，即使您是刚接触C语言的新手，也能通过本文彻底掌握字符串设计的精髓！
探索 Redis 缓存对系统性能的提升——项目启动与操作指南
m0_74139496的博客
04-28 1077
Redis是一款高性能的键值存储数据库，以其出色的读写速度和丰富的数据结构著称，被广泛用作应用系统的缓存层。作为缓存，Redis通过将热点数据存储在内存中，显著降低数据库负载，提升响应速度，尤其适用于高并发场景。它支持字符串、哈希、列表等多种数据类型，可灵活应对不同业务需求，并提供了过期机制、持久化选项及集群部署能力，确保数据可靠性与扩展性。结合LRU淘汰策略，Redis能自动管理内存，避免溢出。此外，其原子操作和发布订阅功能进一步扩展了缓存之外的实时数据处理场景。
redis-单节点-主从节点-哨兵模式
2401_84008551的博客
04-30 689
nohup redis-server /etc/redis.conf >>/data/redis/redis.log 2>&1 & #后台运行启动，以/etc/redis.conf配置文件启动redis服务，日志输出到data/redis目录下。#redis-server /etc/redis.conf >> /data/redis/redis.log & #后台启动redis，与redis.conf里的logfile一致路径。主从或集群的话，程序不再直接连接redis服务了，
Redis 脚本：深入理解与实践指南
csbysj2020
05-03 275
Redis 脚本是一种在 Redis 服务器上执行的编程脚本，它允许用户使用 Lua 脚本语言编写代码，直接在 Redis 服务器上执行复杂的操作。脚本在 Redis 中的执行效率非常高，因为它避免了网络传输的开销。Redis 脚本在 Redis 中发挥着重要作用，它可以帮助开发者实现复杂的操作，提高数据处理的效率。本文从 Redis 脚本概述、应用场景、编写技巧、性能优化等方面进行了详细讲解，希望对读者有所帮助。
【在Spring Boot中集成Redis】
最新发布
m0_52150489的博客
05-03 337
【代码】【在Spring Boot中集成Redis】
哈希表笔记（二）redis
weixin_51147313的博客
05-01 1118
这份代码是Redis核心数据结构之一的字典(dict)实现，本质上是一个哈希表的实现。Redis的字典结构被广泛用于各种内部数据结构，包括Redis数据库本身和哈希键类型。
redis
JK01WYX的博客
04-28 983
Redis 是内存数据库，但是它为数据的持久化提供了两个技术—— 「 AOF 日志和 RDB 快照 」
解决redis序列号和反序列化问题
红烧柯基的博客
04-28 337
最近遇到了一个问题,将类型数据以list形式存入到redis之后,发现取出来时数据格式完全不对,根据报错信息发现是反序列化问题,遇到类似问题,主要有两种解决方案。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值