用Redis实现分布式锁

🕗 发布于 2024-11-18 03:14 redis 分布式 数据库

布式锁的目的是在多个应用程序实例之间协调对共享资源的访问，确保同一时刻只有一个实例能够操作某个资源。这在分布式系统中非常重要，避免多个实例同时修改同一资源时造成数据冲突或不一致。

我们今天的目标是通过 Redis 来实现这种锁。由于 Redis 的高性能，它是实现分布式锁的一种非常流行的工具。

1.Redis分布式锁的创建步骤

1.1 Redis 的基本操作

我们先来回顾一下 Redis 中一些基本的命令，这些命令对实现分布式锁至关重要：

SET key value [EX seconds] [PX milliseconds] [NX|XX]：这个命令非常关键，特别是 NX（如果不存在则设置）和 PX（指定过期时间）选项。
GET key：用于获取某个键的值。
DEL key：删除键。
TTL key：获取一个键的剩余生存时间。

这些命令是实现分布式锁时的基础。

1.2 创建分布式锁的基本思想

在 Redis 中实现分布式锁的基本思想是：

加锁：客户端尝试通过 Redis 设置一个唯一的键（如 lock:resource），并设置一个过期时间（防止死锁）。如果这个键不存在，则加锁成功。如果键已经存在，表示锁已经被其他客户端持有，加锁失败。
解锁：当持锁的客户端完成操作后，应该及时释放锁，删除 Redis 中的键。

1.3 使用 Redis 实现分布式锁

接下来，我们可以通过一个简单的步骤来实现分布式锁。假设我们使用一个键名 lock:resource 来表示资源的锁。

加锁

通过 SET 命令设置一个键 lock:resource，并且要求该键在不存在时设置成功（使用 NX），并且设置过期时间防止死锁（使用 PX）。
```
SET lock:resource unique_lock_value PX 30000 NX
```
- unique_lock_value 是一个唯一的值（例如，可以使用 UUID 来生成唯一值）。
- PX 30000 设置锁的过期时间为 30 秒，防止客户端崩溃后死锁。
- NX 表示只有在 lock:resource 键不存在时才会设置成功。

解锁

解锁时，要确保只有持有锁的客户端才能删除锁。我们需要通过 GET 命令确认当前存储在 Redis 中的值与我们设置时的 unique_lock_value 是否相同，如果相同则删除这个键。
```
if (GET lock:resource == unique_lock_value) { DEL lock:resource }
```

这样我们就完成了一个基础的分布式锁实现。

2.常见问题及其解决方案

2.1 锁的重入问题

在分布式锁中，重入问题意味着一个已经持有锁的客户端，在没有释放锁的情况下又尝试去获取相同的锁。通常情况下，锁是“非重入”的，也就是说，锁只能被持有它的客户端释放，不能被其他客户端“重入”或“重复”持有。为了避免锁被错误释放或者重入，我们需要加以管理。

解决方案：

使用 唯一标识符（unique_lock_value）来识别锁。每次加锁时，生成一个唯一标识符，并在解锁时检查当前的锁值是否与自己加锁时的标识符一致。如果一致，才能释放锁。
如果锁的持有者想重新获取锁，应该确保已经释放了锁，或者让自己加锁时设置合理的过期时间，避免因死锁而造成问题。

2.2 死锁问题

死锁发生的情况比较复杂，通常是由于客户端持有锁时没有及时释放，导致其他客户端无法获取锁。为了避免死锁，我们需要设计合理的锁的超时机制，确保锁不会被永远占用。

解决方案：

使用 Redis 的 过期时间 来避免死锁。锁的过期时间应该设置得足够长，避免在加锁操作中某些未完成的操作因超时而导致锁被释放。
- 比如，我们可以设置一个合理的过期时间（如 30 秒）。如果持有锁的客户端在 30 秒内没有释放锁，锁就会被自动释放，其他客户端可以继续争抢这个锁。
- 注意，锁的过期时间不应该设置得过短，因为在加锁的过程中可能需要一些时间。如果过期时间太短，可能会导致锁被误释放，造成其他客户端无法获取锁。

2.3 锁的延长问题

有时，持有锁的客户端可能需要更多时间来完成任务。如果锁过期，其他客户端就会抢占锁，导致任务执行不完整。

解决方案：

使用 “锁续期” 技术，定期在任务进行时延长锁的过期时间。这可以通过定期向 Redis 发送 SET 命令来更新锁的过期时间。这样即便锁的超时时间接近，也不会被提前释放。
比如，客户端在处理任务时，每隔一段时间检查锁的剩余时间，并使用 SET lock:resource unique_lock_value PX 30000 NX 来延长锁的过期时间。

2.4 锁的公平性问题

在某些场景下，多个客户端可能会竞争同一个锁，导致一些客户端长时间得不到锁。这就涉及到锁的公平性问题。

解决方案：

公平锁的实现通常是通过队列来实现的。可以利用 Redis 的 list 数据结构来模拟队列，让客户端在获取锁时按照顺序进行。
可以使用 Redis 的 阻塞队列，例如通过 BLPOP 或 BRPOP 等命令实现，确保锁是按照队列顺序被分配给客户端的。

2.5 锁的解锁误删问题

在分布式锁中，如果解锁的客户端在没有持有锁的情况下误删了锁，可能会导致其他客户端无法获取到锁。

解决方案：

在解锁时，除了验证锁的值是否为唯一标识符，还可以检查锁的剩余有效期。如果锁已经过期，则可以跳过解锁过程。
锁的标识符要唯一且不可篡改，确保锁值与客户端严格绑定，避免误操作。

2.6 代码示例（加锁、解锁）

假设我们使用 Java 和 Jedis（Redis 客户端）来实现 Redis 分布式锁。

import redis.clients.jedis.Jedis;

public class RedisDistributedLock {
    private static final String LOCK_KEY = "lock:resource"; // 锁的键
    private static final String LOCK_VALUE = "unique_lock_value"; // 锁的唯一标识
    private static final int LOCK_TIMEOUT = 30000; // 锁的过期时间 30 秒

    private Jedis jedis;

    public RedisDistributedLock(Jedis jedis) {
        this.jedis = jedis;
    }

    // 加锁方法
    public boolean acquireLock() {
        String result = jedis.set(LOCK_KEY, LOCK_VALUE, "NX", "PX", LOCK_TIMEOUT);
        return "OK".equals(result);
    }

    // 解锁方法
    public boolean releaseLock() {
        // 只在锁值和自己设置的值相同的时候删除锁，避免误删
        if (LOCK_VALUE.equals(jedis.get(LOCK_KEY))) {
            jedis.del(LOCK_KEY);
            return true;
        }
        return false;
    }

    // 获取锁的方法
    public static void main(String[] args) {
        Jedis jedis = new Jedis("localhost"); // 连接到本地的 Redis 服务
        RedisDistributedLock lock = new RedisDistributedLock(jedis);

        // 获取锁
        if (lock.acquireLock()) {
            System.out.println("获取锁成功！");
            // 执行操作...

            // 释放锁
            if (lock.releaseLock()) {
                System.out.println("释放锁成功！");
            }
        } else {
            System.out.println("获取锁失败！");
        }
    }
}

2.7 总结

到这里，我们已经实现了一个基础的分布式锁，包括加锁、解锁的基本操作，以及如何解决一些常见问题：

重入问题：使用唯一标识符来确保只有持锁的客户端才能释放锁。
死锁问题：使用过期时间来防止锁长时间被占用，避免死锁。
延长锁的有效期：通过定时续期来避免锁过期。
公平性问题：通过队列和阻塞队列来保证锁的公平性。
误删问题：通过锁标识符验证确保锁不被误删。

3. Redlock(红锁)

Redis主从复制模式的异步复制确实可能导致分布式锁的不可靠性，特别是在高并发和网络不稳定的环境下。如果主节点发生故障，从节点可能会滞后，导致读取到的锁状态不一致，进而影响分布式锁的正确性。

为了解决这个问题，Redis 提出了 Redlock（红锁）算法，它是一个基于多个独立的 Redis 实例实现的分布式锁机制，旨在提高分布式锁的可靠性和安全性。

3.1 Redlock 介绍

Redlock 是 Redis 创始人 Salvatore Sanfilippo（Antirez）提出的一种分布式锁算法。它的核心思想是通过多个独立的 Redis 实例来增加容错性，确保即使某些实例发生故障或数据不同步，仍然能够提供高可用的分布式锁服务。

3.2 Redlock 的工作原理

Redlock 的工作原理主要基于以下几点：

多个独立的 Redis 实例：为了确保锁的高可用性和一致性，Redlock 会在多个（至少 5 个）独立的 Redis 实例中尝试加锁。每个 Redis 实例都独立运作，通过它们的集群形式实现分布式锁。
加锁流程：
- 客户端向所有 Redis 实例请求加锁。每个实例都会生成一个唯一的锁值，并设置一个短暂的过期时间（通常设置为几秒到几十秒）。
- 客户端尝试加锁时，要求在多个 Redis 实例中成功设置锁，且在规定的时间内返回成功。
- 如果客户端在规定的时间内，至少有 N/2 + 1 个 Redis 实例返回成功（成功设置锁并且锁未过期），则认为加锁成功。这个数量通常是 3（即至少 3 个 Redis 实例返回成功）。
释放锁：
- 只有锁的持有者才能释放锁。释放时，客户端会向所有 Redis 实例发送释放锁的请求，并检查自己是否是当前锁的持有者（通过锁值进行匹配）。
- 如果是锁的持有者，才会释放锁。
时钟偏差和容错性：
- 为了避免因网络延迟、时钟偏差等问题导致的锁不一致，Redlock 设计了锁过期时间，并要求加锁操作的过程必须在一定时间内完成，避免时间上的不一致性。
- 锁过期时间应该短于实例的网络延迟和响应时间，避免锁超时释放前，客户端已经完成任务。

3.3 Redlock 的优势

高可用性和容错性：通过使用多个 Redis 实例，Redlock 在某个 Redis 实例宕机时，仍然能够依赖其他实例维持分布式锁的正确性。这避免了单点故障的风险。
防止死锁：通过设置锁的过期时间，避免锁永远不被释放，进而解决死锁问题。即使某个客户端发生崩溃或网络问题，锁会自动释放，其他客户端可以继续加锁。
可靠性提升：与单个 Redis 实例的异步复制相比，Redlock 通过多个实例的配合，可以有效减少由于复制滞后引发的不一致性问题。

3.4 Redlock 的工作流程

加锁过程：
1. 客户端通过 SET 命令尝试在多个 Redis 实例上加锁。每个锁设置有唯一标识符和超时时间。
2. 客户端并行地向所有 Redis 实例发送加锁请求。
3. 客户端等待并收集返回的结果，直到获取到至少 N/2 + 1 个实例的锁。
4. 如果超时或无法达到 N/2 + 1 个成功，客户端认为加锁失败。
解锁过程：
1. 客户端持有锁并准备释放时，会向所有 Redis 实例发送解锁请求。
2. 只有持锁的客户端能够释放锁，释放时会校验锁的标识符。
3. 客户端检查每个 Redis 实例的锁值，只有匹配的锁才会被删除，避免误释放。

3.5 Redlock 算法的核心要求

时钟同步：由于锁的过期时间依赖于系统时钟，为避免因时钟不同步导致锁的误释放，Redlock 要求所有 Redis 实例的系统时钟同步，尽量使用 NTP 来保证时钟一致性。
网络延迟：加锁操作需要在短时间内完成，因此需要确保网络延迟在可接受范围内，否则可能会影响 Redlock 的可靠性。

3.6 Redlock 的实现问题和改进

尽管 Redlock 提供了较高的可靠性，但它也存在一些争议和潜在的问题：

性能问题：Redlock 要求多个 Redis 实例并行执行 SET 操作，并等待响应，这可能引入性能瓶颈，尤其在高并发场景下。
一致性问题：由于网络延迟和实例不一致的问题，Redlock 不能保证绝对的分布式一致性。如果锁的过期时间非常短，网络抖动和 Redis 实例的响应时间可能导致部分加锁请求失败。
实现复杂性：相比于单节点 Redis 锁，Redlock 的实现更加复杂。需要协调多个 Redis 实例，处理加锁、解锁以及实例失败时的容错，增加了系统的复杂度。
依赖 Redis 实例的数量：虽然 5 个实例是推荐的数量，但在生产环境中，维护多个 Redis 实例对资源和管理都有较高的要求。

3.7 Redlock 的使用场景

Redlock 特别适用于以下场景：

高可用性需求：对于需要高可用和容错的分布式锁场景，Redlock 是一个非常合适的选择。例如，需要跨多个节点、服务或数据中心的分布式系统。
多实例部署的环境：当应用程序需要跨多个 Redis 实例并保持分布式锁的有效性时，Redlock 可以有效保证锁的一致性。
可靠性要求高的任务调度：例如，任务队列系统中的锁定机制、分布式计算中的任务执行控制等。

3.8 Redlock 实现的代码示例

假设你有 5 个 Redis 实例，你可以使用以下伪代码来实现 Redlock：

public class Redlock {
    private List<Jedis> redisInstances; // 存储多个 Redis 实例
    private String lockKey = "lock:resource"; // 锁的键
    private String lockValue; // 锁的值
    private int lockTimeout = 10000; // 锁的过期时间（毫秒）
    private int majority = 3; // N/2 + 1 个实例

    public boolean acquireLock() {
        int successCount = 0;
        long startTime = System.currentTimeMillis();
        long endTime = startTime + lockTimeout;

        for (Jedis jedis : redisInstances) {
            long currentTime = System.currentTimeMillis();
            if (currentTime > endTime) {
                break;
            }

            String result = jedis.set(lockKey, lockValue, "NX", "PX", lockTimeout);
            if ("OK".equals(result)) {
                successCount++;
            }
        }

        return successCount >= majority;
    }

    public void releaseLock() {
        for (Jedis jedis : redisInstances) {
            if (lockValue.equals(jedis.get(lockKey))) {
                jedis.del(lockKey);
            }
        }
    }
}

Redlock 是 Redis 提出的分布式锁解决方案，旨在解决主从复制异步复制带来的不一致性问题。通过多个 Redis 实例的协作，Redlock 提高了分布式锁的容错性和可靠性。尽管它能够提供更高的可用性，但也引入了性能、实现复杂性等问题，需要在实际应用中根据需求权衡选择。

原文地址：https://blog.csdn.net/m0_53926113/article/details/143759063

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：Mybatis查询ORACLE数据库相近字段名称的值在映射出来的对象中被覆盖
下一篇：Cobalt Strike 4.8 用户指南-第九节 Pivoting（跳板）

[NewStarCTF 2023]include 0。0--详细解析
使用php伪协议时要考虑目标服务器是否开启了相关配置。php://filter有很多变种，目前还不是很熟悉这个伪协议，明天总结一下。
阅读更多2024-11-18
Ubuntu22.04LTS 部署前后端分离项目
（1）将dist上传到云服务器，如我的路径是/home/fcty/frontend/dist这样。（3）将编写好的配置文件复制到对应的/etc/nginx/sites-enabled/下，（2）编写
阅读更多2024-11-18
externally-managed-environment
系统范围：使用 APT。隔离环境：使用虚拟环境或pipx。当前用户：使用--user参数。希望这篇文章能帮助你解决报错问题，并成功完成模块安装！
阅读更多2024-11-18
CTFHub-hate_php
用取反操作，发现环境限制，也不行。利用通配符来匹配文件路径。不能用定义变量的做法。
阅读更多2024-11-18
ThinkPHP中使用ajax接收json数据的方法
在ThinkPHP框架中，使用AJAX接收JSON数据通常涉及前端和后端的交互。前端通过AJAX发送JSON数据到后端，后端控制器接收并处理这些数据，然后可能返回一些响应数据。
阅读更多2024-11-18
计算机网络学习笔记——第一章、概述
学习计算机网络的笔记
阅读更多2024-11-18
基于isSpring的PPT转换
打开 ispring SDK 编辑器，编辑器文件目录默认为 C:\Program Files\iSpring\Platform Ultimate 8\PPT Conversion SDK\CodeBu
阅读更多2024-11-18
flume对kafka中数据的导入导出、datax对mysql数据库数据的抽取
抽取trans_info.json的数据到kafka上，对其中的tr_flag=0的数据进行过滤抛弃，只保留正常的状态数据在pom.xml中放入依赖包：使用java代码，自定义拦截器：@Overrid
阅读更多2024-11-18
基于Kafka2.1解读Consumer原理
Producer的逻辑是把消息往外发，所以Sender运行的越快，client这边为了维护batch而消耗的资源（内存和CPU越少）；而如果Consumer也这么干，实际消费速度赶不上fetch速度的
阅读更多2024-11-18
【开源免费】基于Vue和SpringBoot的私人健身与教练预约管理系统（附论文）
基于java技术、springboot框架、B/S机构、Mysql数据库设计并实现了私人健身与教练预约管理系统。系统主要包括首页，个人中心，用户管理，教练管理，健身项目管理，项目分类，教练信息管理，教
阅读更多2024-11-18

用Redis实现分布式锁

1.Redis分布式锁的创建步骤

1.1 Redis 的基本操作

1.2 创建分布式锁的基本思想

1.3 使用 Redis 实现分布式锁

2.常见问题及其解决方案

2.1 锁的重入问题

2.2 死锁问题

2.3 锁的延长问题

2.4 锁的公平性问题

2.5 锁的解锁误删问题

2.6 代码示例（加锁、解锁）

2.7 总结

3. Redlock(红锁)

3.1 Redlock 介绍

3.2 Redlock 的工作原理

3.3 Redlock 的优势

3.4 Redlock 的工作流程

3.5 Redlock 算法的核心要求

3.6 Redlock 的实现问题和改进

3.7 Redlock 的使用场景

3.8 Redlock 实现的代码示例

相关文章