Redis + Lua 脚本实现分布式锁：从原理到实战，万字详解！

LNU_努力学算法中

1312人浏览 · 2025-02-21 10:19:13

LNU_努力学算法中 · 2025-02-21 10:19:13 发布

开篇互动：你的系统还在用传统的锁机制吗？

“在微服务架构中，资源竞争和并发控制是否是你最头疼的问题？”
在高并发、分布式系统中，传统的互斥锁或同步机制已经无法满足需求。Redis凭借其高性能、高可用性和原子操作特性，成为了分布式锁的事实标准。而结合Lua脚本，则可以进一步提升锁的性能和安全性。

这篇文章将手把手教你如何利用Redis和Lua脚本实现高效、可靠的分布式锁！从基本原理到实战代码，再到优化技巧和常见问题解答，我们一网打尽！

一、分布式锁：为什么我们需要它？

在分布式系统中，多个服务节点可能同时访问共享资源（如数据库、文件等），如果不加以控制，会导致以下问题：

数据不一致：多个节点同时修改同一数据。
资源竞争：多个节点争夺有限资源，导致系统崩溃或性能下降。

解决方案：分布式锁
分布式锁是一种基于分布式存储系统的锁机制，用于控制对共享资源的访问。常见的应用场景包括：

限流：限制系统并发量（如抢购系统）。
资源竞争：控制对共享资源的访问（如数据库写入）。
任务调度：保证任务的唯一性（如定时任务）。

二、Redis 实现分布式锁的核心原理

2.1 Redis 为什么适合实现分布式锁？

Redis 是一个高性能的内存数据库，具有以下特点：

原子操作：Redis 的所有命令都是原子性的，保证了锁操作的安全性。
高性能：Redis 的操作响应时间通常在毫秒级别，适合高并发场景。
过期机制：Redis 支持键的过期时间（TTL），可以自动释放锁。

2.2 Redis 分布式锁的实现方式

Redis 实现分布式锁主要有两种方式：

RedLock 算法：通过多个 Redis 实例实现高可用性。
基于 Lua 脚本的原子操作：通过 Lua 脚本实现复杂的锁逻辑。

本文重点：基于 Lua 脚本的分布式锁
相比 RedLock 算法，基于 Lua 脚本的分布式锁具有以下优势：

原子性：Lua 脚本在 Redis 中是原子执行的，避免了竞态条件。
性能更高：Lua 脚本减少了网络开销，提升了执行效率。

三、Redis + Lua 脚本实现分布式锁的具体步骤

3.1 分布式锁的基本结构

一个典型的分布式锁包含以下关键点：

锁标识：唯一标识一个锁（如 lock:resource_id）。
锁持有者：记录当前持有锁的客户端信息（如 IP 地址或 UUID）。
超时时间：防止死锁（如 30 秒后自动释放）。
重入机制：支持同一个客户端多次获取同一把锁。

3.2 Lua 脚本实现分布式锁

3.2.1 Lua 脚本的基本语法

Lua 是 Redis 的内置脚本语言，支持在服务端执行复杂逻辑。以下是 Lua 脚本的基本语法：

-- 示例：获取一个锁 
local lock_key = KEYS[1]
local client_id = ARGV[1]
local timeout = ARGV[2]
 
-- 检查锁是否存在 
if redis.call("exists",  lock_key) == 0 then 
    -- 锁不存在，设置锁并返回成功 
    redis.call("set",  lock_key, client_id, "EX", timeout)
    return 1 
else 
    -- 锁存在，返回失败 
    return 0 
end

3.2.2 实现加锁逻辑

以下是完整的 Lua 脚本实现加锁逻辑：

-- 加锁脚本 
local lock_key = KEYS[1]
local client_id = ARGV[1]
local timeout = ARGV[2]
 
-- 尝试获取锁 
local result = redis.call("setnx",  lock_key, client_id)
if result == 1 then 
    -- 设置过期时间 
    redis.call("expire",  lock_key, timeout)
    return 1 
else 
    -- 检查当前持有者是否为当前客户端 
    local current_holder = redis.call("get",  lock_key)
    if current_holder == client_id then 
        --是 如果同一个客户端，延长超时时间 
        redis.call("expire",  lock_key, timeout)
        return 1 
    else 
        -- 如果不是同一个客户端，返回失败 
        return 0 
    end 
end

3.2.3 实现解锁逻辑

以下是 Lua 脚本实现解锁逻辑：

-- 解锁脚本 
local lock_key = KEYS[1]
local client_id = ARGV[1]
 
-- 获取当前持有者 
local current_holder = redis.call("get",  lock_key)
if current_holder == client_id then 
    -- 如果是当前客户端，删除锁 
    redis.call("del",  lock_key)
    return 1 
else 
    -- 如果不是当前客户端，返回失败 
    return 0 
end

3.3 Java 项目中的实现

3.3.1 引入 Redis 依赖

在 Maven 项目中添加 Redis 依赖：

<!-- pom.xml  添加依赖 -->
<dependency>
    <groupId>redis.clients</groupId> 
    <artifactId>jedis</artifactId>
    <version>4.2.3</version>
</dependency>

3.3.2 编写加锁和解锁代码

以下是 Java 代码实现加锁和解锁逻辑：

import redis.clients.jedis.Jedis; 
import redis.clients.jedis.JedisPool; 
import redis.clients.jedis.Transaction; 
import redis.clients.jedis.exceptions.JedisException; 
 
import java.util.UUID; 
 
public class DistributedLock {
    private static final JedisPool jedisPool = new JedisPool("localhost", 6379);
    private static final String LOCK_SCRIPT = "load.lua";  // Lua 脚本文件路径 
 
    public boolean acquireLock(String lockKey, int timeout) {
        try (Jedis jedis = jedisPool.getResource())  {
            String client_id = UUID.randomUUID().toString(); 
            Object result = jedis.evalsha(LOCK_SCRIPT,  1, lockKey, client_id, timeout);
            return (Long) result == 1L;
        } catch (JedisException e) {
            e.printStackTrace(); 
            return false;
        }
    }
 
    public boolean releaseLock(String lockKey) {
        try (Jedis jedis = jedisPool.getResource())  {
            String client_id = UUID.randomUUID().toString(); 
            Object result = jedis.evalsha(UNLOCK_SCRIPT,  1, lockKey, client_id);
            return (Long) result == 1L;
        } catch (JedisException e) {
            e.printStackTrace(); 
            return false;
        }
    }
}