分布式 - redis分布式锁

作者： 分类：所有,分布式 字数：8414

'# 分布式 - redis分布式锁

一、背景与问题

在分布式系统中，多个服务实例可能需要协调访问共享资源。传统锁机制在单机环境中表现良好，但无法满足分布式场景下的需求。例如：

  • 多个微服务实例同时操作共享数据库时
  • 分布式任务队列中的任务调度
  • 分布式缓存中的热点数据更新

传统锁机制存在以下局限性：

  1. 跨进程无法直接通信：无法保证多个进程间的锁一致性
  2. 网络分区风险：网络故障可能导致锁丢失或死锁
  3. 资源竞争问题：多个进程同时访问同一资源时的协调问题

为了解决这些问题，需要一种分布式锁机制，能够跨进程/跨服务器协调资源访问。Redis 提供了基于 SET 命令的分布式锁实现，但需要正确设计才能保证其可靠性。

二、基本原理

Redis 分布式锁的核心原理是利用 Redis 的单线程特性，通过 SET 命令的 NX（Not eXist）和 EX（Expire）选项来实现：

  1. 加锁：使用 SET key value NX EX timeout 命令尝试设置键值

    • NX 保证只有当键不存在时才设置成功
    • EX 设置键的过期时间，防止锁无限期占用

  2. 解锁：使用 Lua 脚本确保原子性操作

    • 需要验证锁的持有者（value）与当前进程的标识是否一致
    • 避免误删其他进程的锁

关键点：

  • 原子性：必须使用 Lua 脚本保证解锁操作的原子性
  • 过期时间：需要合理设置超时时间，避免锁无法释放
  • 锁续期：需要在业务逻辑中实现锁的续期机制

三、环境准备

在开始前需要准备以下环境：

  1. Redis 服务器：至少 6.0.0 版本（支持 Lua 脚本）
  2. 开发环境：Node.js 18+ 或 Python 3.8+
  3. 测试工具：Postman 或 curl 命令行工具

3.1 Redis 配置示例

# redis.conf 配置文件
maxmemory 2gb
maxmemory-policy allkeys-lru
appendonly yes

3.2 Node.js 项目结构

distributed-lock/
├── index.js          # 主程序
├── redis-lock.js     # Redis 锁核心逻辑
├── lock-utils.js     # 工具函数
├── package.json
└── README.md

四、核心实现

4.1 基础加锁实现（Node.js）

// redis-lock.js
const redis = require('redis');
const client = redis.createClient({ host: 'localhost', port: 6379 });

async function acquireLock(lockKey, expireTime = 30000) {
  const lockValue = `lock:${Date.now()}`;
  const result = await client.set(lockKey, lockValue, 'NX', 'EX', expireTime);
  return result === 'OK';
}

关键代码解释：

  • NX 确保只有当键不存在时才设置成功
  • EX 设置过期时间，防止锁无限期占用
  • 返回值为 'OK' 表示成功获取锁

4.2 安全解锁实现（Lua 脚本）

// redis-lock.js
async function releaseLock(lockKey, lockValue) {
  const script = `
    if redis.call('get', KEYS[1]) == ARGV[1] then
      return redis.call('del', KEYS[1])
    else
      return 0
    end
  `;
  
  const result = await client.eval(script, 1, lockKey, lockValue);
  return result === 1;
}

关键代码解释：

  • 使用 Lua 脚本确保原子性
  • 检查锁的值是否与当前进程标识一致
  • 成功删除锁返回 1，否则返回 0

4.3 带续期的锁实现

// lock-utils.js
class RedisLock {
  constructor(client, lockKey, expireTime = 30000) {
    this.client = client;
    this.lockKey = lockKey;
    this.expireTime = expireTime;
    this.lockValue = `lock:${Date.now()}`;
  }

  async acquire() {
    const result = await this.client.set(this.lockKey, this.lockValue, 'NX', 'EX', this.expireTime);
    return result === 'OK';
  }

  async renew() {
    const script = `
      if redis.call('get', KEYS[1]) == ARGV[1] then
        return redis.call('expire', KEYS[1], ARGV[2])
      else
        return 0
      end
    `;
    
    const result = await this.client.eval(script, 1, this.lockKey, this.lockValue, this.expireTime);
    return result === 1;
  }

  async release() {
    const script = `
      if redis.call('get', KEYS[1]) == ARGV[1] then
        return redis.call('del', KEYS[1])
      else
        return 0
      end
    `;
    
    const result = await this.client.eval(script, 1, this.lockKey, this.lockValue);
    return result === 1;
  }
}

关键代码解释：

  • renew 方法用于续期锁的过期时间
  • 使用 Lua 脚本确保续期操作的原子性
  • 确保只有持有锁的进程才能续期

五、完整案例

5.1 分布式任务调度系统

// index.js
const RedisLock = require('./redis-lock');
const { promisify } = require('util');

const client = redis.createClient({ host: 'localhost', port: 6379 });
const acquireLock = promisify(client.set).bind(client);
const releaseLock = promisify(client.eval).bind(client);

async function executeTask(taskId) {
  const lockKey = `task:${taskId}`;
  const lockValue = `lock:${Date.now()}`;
  
  try {
    const acquired = await acquireLock(lockKey, lockValue, 'NX', 'EX', 30000);
    if (!acquired) {
      console.log(`Task ${taskId} failed to acquire lock`);
      return;
    }
    
    console.log(`Task ${taskId} acquired lock`);
    // 模拟任务执行
    await new Promise(resolve => setTimeout(resolve, 1000));
    
    console.log(`Task ${taskId} completed`);
  } finally {
    await releaseLock(
      lockKey,
      lockValue,
      `
        if redis.call('get', KEYS[1]) == ARGV[1] then
          return redis.call('del', KEYS[1])
        else
          return 0
        end
      `,
      1,
      lockKey,
      lockValue
    );
  }
}

// 模拟多实例并发执行
for (let i = 0; i < 5; i++) {
  setTimeout(() => executeTask(`task-${i}`), i * 100);
}

运行结果示例：

Task task-0 acquired lock
Task task-1 acquired lock
Task task-2 acquired lock
Task task-3 acquired lock
Task task-4 acquired lock
Task task-0 completed
Task task-1 completed
Task task-2 completed
Task task-3 completed
Task task-4 completed

六、源码解析

6.1 Redis SET 命令的原子性保证

Redis 的 SET 命令支持多个选项，其中 NX 和 EX 的组合确保了分布式锁的原子性：

SET key value NX EX timeout
  • NX：只有当 key 不存在时才设置成功
  • EX：设置 key 的过期时间（单位：秒）

这个组合保证了两个关键条件：

  1. 只有当锁未被占用时才设置成功
  2. 锁会在指定时间后自动释放

6.2 Lua 脚本的原子性执行

Redis 的 Lua 脚本在服务器端执行，具有原子性保证：

if redis.call('get', KEYS[1]) == ARGV[1] then
  return redis.call('del', KEYS[1])
else
  return 0
end
  • KEYS[1] 是锁的 key
  • ARGV[1] 是锁的 value
  • 脚本返回 1 表示成功删除锁，0 表示未找到锁

6.3 锁续期的实现原理

if redis.call('get', KEYS[1]) == ARGV[1] then
  return redis.call('expire', KEYS[1], ARGV[2])
else
  return 0
end
  • ARGV[2] 是新的过期时间
  • 仅当锁的 value 与当前进程标识一致时才续期
  • 保证了续期操作的原子性

七、进阶使用

7.1 可重入锁实现

class ReentrantLock {
  constructor(client, lockKey, expireTime = 30000) {
    this.client = client;
    this.lockKey = lockKey;
    this.expireTime = expireTime;
    this.lockValue = `lock:${Date.now()}`;
    this.reentrantCount = 0;
  }

  async acquire() {
    const result = await this.client.set(this.lockKey, this.lockValue, 'NX', 'EX', this.expireTime);
    if (result === 'OK') {
      this.reentrantCount = 1;
      return true;
    }
    
    const currentCount = await this.client.get(this.lockKey);
    if (currentCount === this.lockValue) {
      this.reentrantCount++;
      return true;
    }
    
    return false;
  }

  async release() {
    this.reentrantCount--;
    if (this.reentrantCount === 0) {
      await this.client.del(this.lockKey);
    }
  }
}

关键点：

  • 使用计数器实现可重入锁
  • 在释放锁时需要判断是否需要真正删除锁
  • 需要处理并发释放的情况

7.2 Redlock 算法实现

async function redlock(lockKeys, clientId, expireTime) {
  const acquirePromises = lockKeys.map(key => 
    client.set(key, clientId, 'NX', 'EX', expireTime)
  );
  
  const results = await Promise.allSettled(acquirePromises);
  const acquiredCount = results.filter(r => r.status === 'fulfilled').length;
  
  if (acquiredCount >= lockKeys.length / 2) {
    // 所有锁都成功获取
    return true;
  }
  
  // 释放部分锁
  const releasePromises = results
    .filter(r => r.status === 'fulfilled')
    .map((_, index) => client.del(lockKeys[index]));
  
  await Promise.all(releasePromises);
  return false;
}

关键点：

  • 使用多个锁保证可靠性
  • 需要处理锁的释放逻辑
  • 适用于高可靠性的场景

八、性能与工程实践

8.1 性能优化方法

优化策略说明示例
精确锁粒度将锁粒度控制在最小范围使用 task:123 而不是 global_lock
避免锁竞争使用队列系统替代锁使用 RabbitMQ 处理任务队列
锁续期策略使用定时任务续期每隔 500ms 续期一次
异步释放锁在业务逻辑完成后异步释放使用消息队列发送释放信号

8.2 安全风险分析

  1. 锁误删风险：未使用 Lua 脚本可能导致误删其他进程的锁

    • 解决方案：始终使用 Lua 脚本进行解锁

  2. 锁泄漏风险：未正确释放锁导致资源占用

    • 解决方案：使用 try-finally 确保释放锁

  3. 过期时间设置不当：过短可能导致任务未完成就释放锁

    • 解决方案：根据业务需求合理设置过期时间

  4. 网络分区风险：网络故障可能导致锁丢失

    • 解决方案：结合持久化存储和重试机制

九、常见问题与踩坑

9.1 常见错误及解决方案

错误类型错误示例解决方案
锁未释放client.set(lockKey, value, 'NX')始终使用 EX 设置过期时间
误删锁client.del(lockKey)使用 Lua 脚本确保原子性
竞态条件多个进程同时获取锁使用 NX 和 EX 确保原子性
锁未续期未在业务逻辑中续期使用定时任务或间隔续期

9.2 常见坑点

  1. 未设置过期时间：导致锁无法释放，造成资源浪费
  2. 未处理异常：未在 try-finally 中释放锁
  3. 锁标识不唯一：未使用唯一标识导致误删
  4. 未处理续期失败：未处理续期失败导致锁过期

十、最佳实践

10.1 推荐实践

  1. 使用唯一标识：在锁值中包含唯一标识（如时间戳）
  2. 设置合理超时：根据业务需求设置合理的过期时间
  3. 使用 Lua 脚本：确保解锁操作的原子性
  4. 续期机制：在业务逻辑中实现锁的续期
  5. 监控机制：添加锁的监控和告警

10.2 不推荐实践

  1. 使用 SET 单独处理：未使用 NX 和 EX 导致锁失效
  2. 直接删除锁：未使用 Lua 脚本导致误删
  3. 未处理续期失败：导致锁过期后仍占用资源
  4. 未处理异常：未在 try-finally 中释放锁

十一、总结

Redis 分布式锁是实现分布式系统资源协调的重要工具，但需要正确理解和使用。本文深入探讨了其工作原理，提供了多个代码示例和完整案例，分析了常见错误及解决方案，讨论了性能优化和安全风险。

在实际开发中，需要根据业务需求选择合适的实现方式：

  • 简单场景：使用基础的 SET 命令和 Lua 脚本
  • 高可靠性场景：使用 Redlock 算法
  • 可重入场景：实现可重入锁
  • 高性能场景：结合队列系统减少锁竞争

使用 Redis 分布式锁时需要注意：

  • 始终使用 Lua 脚本确保原子性
  • 合理设置过期时间
  • 实现锁的续期机制
  • 处理异常情况确保锁释放
  • 监控锁的使用情况

通过合理设计和实践，可以有效利用 Redis 分布式锁解决分布式系统中的资源协调问题。

分布式
最后修改于：2026年09月22日 02:26

评论已关闭

推荐阅读

AIGC实战——Transformer模型
2024年12月01日
python , AI , 机器学习
Socket TCP 和 UDP 编程基础（Python）
2024年11月30日
python , tcp , udp
如何使用 ChatGPT 进行学术润色？你需要这些指令
2024年12月01日
AI
最新 Python 调用 OpenAi 详细教程实现问答、图像合成、图像理解、语音合成、语音识别（详细教程）
2024年11月24日
python , AI
ChatGPT 和 DALL·E 2 配合生成故事绘本
2024年12月01日
python , AI
omegaconf，一个超强的 Python 库！
2024年11月24日
python
【视觉AIGC识别】误差特征、人脸伪造检测、其他类型假图检测
2024年12月01日
python , AI
［超级详细］如何在深度学习训练模型过程中使用 GPU 加速
2024年11月29日
python , AI , 机器学习
Python 物理引擎pymunk最完整教程
2024年11月27日
python
MediaPipe 人体姿态与手指关键点检测教程
2024年11月27日
python
深入了解 Taipy：Python 打造 Web 应用的全面教程
2024年11月26日
python
基于Transformer的时间序列预测模型
2024年11月25日
python , Matplotlib , 机器学习
Python在金融大数据分析中的AI应用（股价分析、量化交易）实战
2024年11月25日
python , Matplotlib , 机器学习
AIGC Gradio系列学习教程之Components
2024年12月01日
python , AI
Python3 `asyncio` — 异步 I/O，事件循环和并发工具
2024年11月30日
python
llama-factory SFT系列教程：大模型在自定义数据集 LoRA 训练与部署
2024年12月01日
python , AI , 机器学习
Python 多线程和多进程用法
2024年11月24日
python
Python socket详解，全网最全教程
2024年11月27日
python , http , websocket
python之plot()和subplot()画图
2024年11月26日
python , Matplotlib
理解 DALL·E 2、Stable Diffusion 和 Midjourney 工作原理
2024年12月01日
python , AI , 机器学习
Copyright © 2026 Tech Blog
All Right Reserved | 京ICP备19053165号