分布式锁总结2 - redis实现分布式锁并解决常见问题

已于 2024-09-18 16:31:19 修改
阅读量1.4k 收藏 10
点赞数 30
CC 4.0 BY-SA版权
文章标签： 分布式
于 2024-09-18 14:09:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/weixin_49418695/article/details/142327772

目录

1. redis分布式锁

1.1基本原理图示如下

1.2 Redis通过一个lock变量实现一个最简单的分布式锁实现代码：

2 升级简单分布式锁（实现原子加锁与安全删锁）

2.1 但1中的简单分布式锁存在几个问题：

2.1.1 问题1. 如果加完锁执行业务过程中，还未到释放锁的环节，系统中断，出现死锁的情况，怎么解决？

2.2.2 问题2. 业务未完成，锁到期自动释放，但把别人正在持有的锁删除了，应该如何解决（如下图）？

2.2 针对以上问题我们将上述分布式锁代码升级为如下代码：

3. 继续升级分布式锁（实现原子删锁）

3.1 此分布式锁解决了上述的问题1与问题2，但释放锁还存在问题

3.1.1 问题3. 在线程A释放锁时，因是先发送请求获取到锁A的value，对比成功后，删除。若线程A在对比成功以后，删除锁之前，锁刚好自动过期，而另一个线程B抢占到资源，刚好加上锁。则此时线程A刚好执行删除操作则会删除线程B的锁。应该如何解决（如下图）？

3.2 实现原子删除操作的代码

4. 完整实现代码

5. 总结

1. redis分布式锁

1.1基本原理图示如下

1.2 Redis通过一个lock变量实现一个最简单的分布式锁实现代码：

//查询缓存中没有想要获取的数据
//开始
String lockKey = "lock_key";
// 1 获取锁。即“占坑”操作
boolean locked = jedis.set(lockKey, "lockValue", "NX") != null;

if (locked) {
    try {
        //1.1 加锁成功
        // 1.1.1 执行业务逻辑,即查询数据库获得数据并返回
    } finally {
        // 1.1.2 释放锁
         jedis.del(lockKey);
    }
} else {
    // 1.2 未获取锁，处理逻辑
    //1.2.1 休眠100ms 为避免重试频率过高
    return //1.2.2 返回本方法
    //通过返回本方法实现自旋，不断尝试获取锁
}

2 升级简单分布式锁（实现原子加锁与安全删锁）

上述的方法可以实现一个简单的分布式锁，即所有资源抢占时所有服务器排队抢占锁。

2.1 但1中的简单分布式锁存在几个问题：

2.1.1 问题1. 如果加完锁执行业务过程中，还未到释放锁的环节，系统中断，出现死锁的情况，怎么解决？

        解决方案：设置锁自动过期时间，且必须在加锁的同时设置过期时间（必须为原子操作，分开操作也可能会导致死锁问题）。

2.2.2 问题2. 业务未完成，锁到期自动释放，但把别人正在持有的锁删除了，应该如何解决（如下图）？

        解决方案：加锁时指定value为自己的uuid，释放锁时匹配自己的uuid才能释放。

2.2 针对以上问题我们将上述分布式锁代码升级为如下代码：

//查询缓存中没有想要获取的数据
//开始
String lockKey = "lock_key";
String clientId = UUID.randomUUID().toString(); // 用于标识持有锁的客户端
int lockTimeout = 10; // 锁的过期时间，单位为秒

// 1 获取锁。即“占坑”操作（原子操作设置过期时间，解决问题1）
boolean locked = jedis.set(lockKey, clientId, "NX", "EX", lockTimeout) != null;

if (locked) {
    try {
        //1.1 加锁成功
        // 1.1.1 执行业务逻辑,即查询数据库获得数据并返回
    } finally {
        // 1.1.2 释放锁
        if (clientId.equals(jedis.get(lockKey))) {
            //只能删除自己的锁（解决问题2）
            jedis.del(lockKey);
        }
    }
} else {
    // 1.2 未获取锁，处理逻辑
    //1.2.1 休眠100ms 为避免重试频率过高
    return //1.2.2 返回本方法
    //通过返回本方法实现自旋，不断尝试获取锁
}

上述代码成功实现了原子加锁与只能删除自己锁的功能，成功解决了前面提出的两个问题。

3. 继续升级分布式锁（实现原子删锁）

3.1 此分布式锁解决了上述的问题1与问题2，但释放锁还存在问题

3.1.1 问题3. 在线程A释放锁时，因是先发送请求获取到锁A的value，对比成功后，删除。若线程A在对比成功以后，删除锁之前，锁刚好自动过期，而另一个线程B抢占到资源，刚好加上锁。则此时线程A刚好执行删除操作则会删除线程B的锁。应该如何解决（如下图）？

        解决方案：释放锁即删除锁时执行原子操作，而删除锁无法像加锁时那么简单，此处使用lua脚本实现原子操作删除锁。

// Lua 脚本，用于原子性释放锁
    private static final String releaseLockScript =
        "if redis.call('get', KEYS[1]) == ARGV[1] then " +
        "   return redis.call('del', KEYS[1]) " +
        "else " +
        "   return 0 " +
        "end";
//上述脚本实现功能为 get查询变量KEYS[1]的值是否等于ARGV[1] ，
//如果等则del删除变量KEYS[1]，否则结束脚本

        然后在代码中执行上述脚本即可完成删除锁的原子操作，因为脚本是一个整体，查询与删除完成或者失败是一体的。

3.2 实现原子删除操作的代码

    private static final String lockKey = "lock_key"; // 锁的 Redis key
    private static final String clientId = UUID.randomUUID().toString(); // 用于标识持有锁的客户端
    private static final int lockTimeout = 10; // 锁超时时间，单位：秒

    private Jedis jedis; // Redis 客户端
    // Lua 脚本，用于原子性释放锁
    private static final String releaseLockScript =
        "if redis.call('get', KEYS[1]) == ARGV[1] then " +
        "   return redis.call('del', KEYS[1]) " +
        "else " +
        "   return 0 " +
        "end";

    public String getDataFromCacheOrDb() {
        // 1. 先查询缓存，判断缓存中是否已经有数据

        // 2. 缓存未命中，尝试获取分布式锁
        boolean locked = jedis.set(lockKey, clientId, "NX", "EX", lockTimeout) != null;
        if (locked) {
            try {
                // 再次检查缓存，避免多个线程在锁之前都没有缓存
                // 3. 缓存依然未命中，去数据库中获取数据
                // 4. 将数据写入缓存，设置一个过期时间
                return dbData;

            } finally {
                // 5. 释放锁，使用 Lua 脚本确保只有当前持有锁的客户端才能删除锁
                jedis.eval(releaseLockScript, Collections.singletonList(lockKey), Collections.singletonList(clientId));
            }
        } else {
            // 6. 如果未获取到锁，等待其他线程完成缓存操作，稍作延迟后再次尝试读取缓存
            try {
                Thread.sleep(100); // 短暂休眠，等待其他线程完成操作
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }

            // 7. 重新从缓存读取数据
            return ;
        }
    }

4. 完整实现代码

模拟获取热点数据整个流程：

import redis.clients.jedis.Jedis;
import java.util.Collections;
import java.util.UUID;

public class CacheService {

    private static final String lockKey = "lock_key"; // 锁的 Redis key
    private static final String cacheKey = "hotspot_data"; // 缓存中的 key
    private static final String clientId = UUID.randomUUID().toString(); // 用于标识持有锁的客户端
    private static final int lockTimeout = 10; // 锁超时时间，单位：秒

    private Jedis jedis; // Redis 客户端

    // Lua 脚本，用于原子性释放锁
    private static final String releaseLockScript =
        "if redis.call('get', KEYS[1]) == ARGV[1] then " +
        "   return redis.call('del', KEYS[1]) " +
        "else " +
        "   return 0 " +
        "end";

    public String getDataFromCacheOrDb() {
        // 1. 先查询缓存，判断缓存中是否已经有数据
        String cachedData = jedis.get(cacheKey);
        if (cachedData != null) {
            return cachedData; // 缓存命中，直接返回数据
        }

        // 2. 缓存未命中，尝试获取分布式锁 实现原子加锁
        boolean locked = jedis.set(lockKey, clientId, "NX", "EX", lockTimeout) != null;
        if (locked) {
            try {
                // 再次检查缓存，避免多个线程在锁之前都没有缓存
                cachedData = jedis.get(cacheKey);
                if (cachedData != null) {
                    return cachedData; // 如果其他线程已经缓存了数据，直接返回
                }

                // 3. 缓存依然未命中，去数据库中获取数据
                String dbData = getDataFromDb(); // 从数据库中获取数据

                // 4. 将数据写入缓存，设置一个过期时间
                jedis.setex(cacheKey, 60, dbData); // 60秒缓存有效期，实际情况按需求调整
                return dbData;

            } finally {
                // 5. 释放锁，使用 Lua 脚本确保只有当前持有锁的客户端才能删除锁 实现原子删锁
                jedis.eval(releaseLockScript, Collections.singletonList(lockKey), Collections.singletonList(clientId));
            }
        } else {
            // 6. 如果未获取到锁，等待其他线程完成缓存操作，稍作延迟后再次尝试读取缓存
            try {
                Thread.sleep(100); // 短暂休眠，等待其他线程完成操作
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
            }

            // 7. 重新从缓存读取数据
            return jedis.get(cacheKey);
        }
    }

    // 模拟从数据库获取数据
    private String getDataFromDb() {
        // 实际中，这里会执行数据库查询操作
        return "data_from_db";
    }
}

 经过升级后的最终分布式锁流程图如下：

5. 总结

分布式锁实现过程:

借助 SET 命令实现加分布式锁原子操作：

• SET key value NX EX seconds：

（NX 表示只有当键不存在时才设置值（即，保证了原子性，避免了多个客户端同时获取锁））。

（EX 设置锁的过期时间，防止锁永远不会释放（即死锁情况））。

实现步骤：

1. 尝试使用 SET key value NX EX seconds 来加锁，实现原子操作。

• 如果返回 OK，说明锁获取成功。

• 如果返回 nil，说明锁已经被其他客户端持有，获取失败。

2. 如果成功获取锁，执行关键业务逻辑。

3. 业务完成后，通过lua脚本释放锁，实现原子操作。

Redis分布式锁的问题与解决方案
Book_Sea的博客
09-29 215
其他客户端可以在锁过期后获取到该锁，并继续执行任务。如果setnx返回True，表示成功获取到锁，我们还可以通过expire函数设置锁的过期时间，以防止锁被长时间占用。在上述代码中，我们使用了Redis的get命令来获取当前锁的值，如果与预期值相等，则通过delete命令手动释放锁。在某些情况下，任务的执行时间可能超过锁的过期时间，导致其他客户端在任务尚未完成时获取到了锁，从而引发并发访问问题。在上述代码中，我们使用了Redis的set命令，并通过nx参数设置了锁的独占性，ex参数设置了锁的过期时间。
使用Redis进行分布式锁时需要注意哪些问题？Redis分布式锁的常见实现方式有哪些？
linzhongshu的专栏
07-07 969
使用 Redis 的 Lua 脚本：通过编写 Lua 脚本来实现获取锁和设置过期时间的逻辑，确保操作的原子性。，可以在一条命令中完成设置键值和设置过期时间的操作，并且保证原子性。为该键设置过期时间。但这种方式不是原子操作，可能存在问题。尝试设置一个键，如果设置成功（说明获取到锁），再使用。
redis做分布式锁的问题
wnhyang的博客
11-28 470
参考 谷粒商城p158：https://www.bilibili.com/video/BV1np4y1C7Yf?p=158 redis官网：http://www.redis.cn/commands/set.html 提要 分布式场景下将原有的本地锁换为，基于redis的setnx命令的分布式锁 getCatalogJsonFromDb：从数据库查数据 getCatalogJsonFromDbWithLocalLock：利用本地锁查数据 getCatalogJsonFromDbWithRedisLock：利
redis--分布式锁详解
最新发布
m0_73856804的博客
06-26 725
redisson分布式锁原理：可重入：利用hash结构记录线程id和重入次数，当线程获取锁失败后去判断锁包含的线程id是否一致，如果一致，则让其获取锁，并且重入次数加一。在释放锁时，先去判断锁中的线程ID，再去判断重入次数是否为0，如果为0，则释放，不为0，则无视可重试：利用信号量和pubsub功能实现等待、唤醒、获取锁失败的重试机制。在第一次获取锁失败以后，并不是直接返回false，尝试获取锁的返回结果就是ttl（剩余有效时间），如果返回值为null。则获取锁成功，若不为null，则获取锁失败，
Redis 实现分布式锁时需要考虑的问题
lssffy的博客
09-28 1579
分布式锁是一种协调机制，用于确保在分布式系统中多个进程或线程可以安全地访问共享资源。通过分布式锁，可以确保在同一时间只有一个节点可以对某个资源进行操作，从而避免数据竞争或资源冲突。Redis作为一种高性能的内存型数据库，因其对原子操作的支持和极高的吞吐量，被广泛应用于分布式锁的实现中。然而，使用Redis实现分布式锁时，开发者需要考虑多个问题，包括锁的获取与释放、超时处理、宕机容错、网络分区等。通过合理的设计和优化，可以保证Redis分布式锁在高并发环境下的稳定性和安全性。
Redis分布式锁问题
z275598733的博客
08-13 397
引入新的问题：1、需要保证加锁和超时操作的原子性 2、业务运行超过超时时间，导致解锁了其他线程的锁 3、超时时间。问题：1、需要保证加锁和超时操作的原子性 2、业务运行超过超时时间，导致解锁了其他线程的锁。仍有问题：1、比对uuid和解锁的过程不是原子的 2、业务运行未结束，锁提前释放。问题：1、比对uuid和解锁的过程不是原子的 2、业务运行未结束，锁提前释放。2、业务分布式情况下，使用redis的setNX，实现加锁解锁，保证业务前加锁，业务后解锁。4、分布式锁实现过程中遇到的问题、
Redis系列：使用Redis实现分布式锁及相关问题
栗筝i的博客
11-11 6007
分布式锁其实就是，控制分布式系统不同进程共同访问共享资源的一种锁的实现。如果不同的系统或同一个系统的不同主机之间共享了某个临界资源，往往需要互斥来防止彼此干扰，以保证一致性。 本篇内容包括：关于 Redis 与 分布式锁，Redis 分布式锁的问题及解决方式，Redis 中的 Lua 脚本 以及 Redis 中的 RedLock 算法！
分布式锁实现方案--redis、zookeeper、mysql
ljran0612的专栏
08-13 1510
因为我这里是以三个节点为例。锁key的值附加唯一性：针对释放别人锁这种问题，我们可以给每个客户端进程设置【唯一ID】，作为锁（所有客户端锁key相同）的值，这样我们就可以在应用层就进行检查唯一ID。我们了解下什么是【可重入】：指的是同一个线程在持有锁的情况下，可以多次获取该锁而不会造成死锁，也就是一个线程可以在获取锁之后再次获取同一个锁，而不需要等待锁释放。InterProcessMultiLock：将多个锁作为单个实体管理的容器，获取锁的时候获取所有锁，释放锁也会释放所有锁资源（忽略释放失败的锁）。
Redis实现分布式锁(附源码+讲义)
07-01
在学习Java多线程编程的时候，锁是一个很重要也很基础的概念，锁可以看成是多线程情况下访问共享资源的一种线程同步机制。这是对于单进程应用而言的，即... 掌握redis分布式锁常见的面试题 以下是课程部分讲义截图：
Redis分布式锁python-redis-lock使用方法
01-21
python-redis-lock 多个redis客户端访问同一个redis服务端，控制并发。 github：https://pypi.org/project/python-redis-lock/ 在使用这个库之前，需要安装如下： pip install python-redis-lock 使用锁的示例： ...
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
总结来说，通过Redis实现分布式锁，可以有效解决多节点间的资源竞争问题。使用自旋式加锁策略可以确保锁的获取，而Lua脚本则为解锁提供了原子性保证，从而避免了并发环境下的数据一致性问题。在实际应用中，还可以...
Spring项目整合Redis分布式锁全解析
恩爸编程
01-29 1298
通过以上步骤，我们成功在Spring项目中整合了Redis分布式锁，实现了对共享资源的安全访问控制。异常处理：在获取和释放锁的过程中，可能会出现各种异常，需要进行适当的异常处理，确保系统的稳定性。锁的优化：可以根据业务需求，对锁的过期时间、重试机制等进行优化，提高系统性能。集群环境：在Redis集群环境下，需要考虑使用更高级的分布式锁算法，如Redlock算法，以确保锁的可靠性和容错性。
Redis分布式锁实现方式及超时问题解决
08-19
主要介绍了Redis分布式锁实现方式及超时问题解决,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
Redis分布式锁存在的问题以及解决方式
个人博客，欢迎收藏。
01-18 1887
带你一起解决Redis分布式锁存在的问题。
Redis分布式锁及其常见问题解决方案
栗筝i的博客
09-21 5926
Redis 提供了一种简单有效的分布式锁实现方式。其基本思想是使用 Redis 的 SETNX 命令，这个命令可以在键不存在时设置值，如果键已存在则不做任何操作。通过这个原子操作，我们可以实现在多个节点之间的互斥访问。 然而，虽然 Redis 分布式锁的实现相对简单，但在实际使用中还需要考虑很多问题，例如锁的超时和续期问题、锁的公平性问题、网络分区的问题等。在接下来的文章中，我们将详细介绍这些问题以及解决方案。
【redis知识点整理】 --- redis实现分布式锁需要解决的问题
nrsc
05-30 1331
本文代码对应的github地址：https://github.com/nieandsun/redis-study 文章目录1 超卖现象简单介绍 1 超卖现象简单介绍 有如下代码： @RestController public class RedisLockController { @Autowired private StringRedisTemplate stringRedisTemplate; @GetMapping("/deduct_stock") public.
redis分布式锁问题
qq_3316359388的博客
03-24 1148
建立redis集群，作为分布式锁。 1.如果客户端1挂掉怎么办？ 给锁加一个过期时间
redis实现分布式锁问题
你走过的路 风都是暖的
12-20 1150
现在的多数电商公司都会采用分布式架构，分布式部署，如下单，简单的描述 拿订单秒杀模块举例，通常我们实现秒杀会采用redis缓存技术，活动举行前把相应的库存数存储到redis里边 由图看以看出，在高并发的场景下，很容易造成库存的不一致问题。传统的锁像 synchronized 在此场景下就会失效。 此时，我们需要一把锁，在多个线程下都能上锁。 思考： redis的 setnx方法：redis执行setnx 添加数据时，若redis中存在相同的key，那么redis中的数据不会发生变化。 re
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

One day️

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值