Redis：手写分布式锁

已于 2023-09-13 22:43:45 修改
阅读量131 收藏 1
点赞数
分类专栏： redis学习 文章标签： redis 分布式 数据库
于 2023-09-12 16:14:11 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lifetime_gear/article/details/132834722
版权

本文将在RedisTemplate中使用Redis的String类型或Hash类型来迭代式实现一个分布式锁的基本功能（互斥、防误删）和附加功能（可重入、自动续期）。

目录

1.0原始版本

2.0Setnx自旋锁版本

3.0Setnx自旋+过期锁版本

3.1Setnx自旋+过期plus锁版本

4.0Setnx自旋+防误删+过期锁版本

5.0Setnx自旋+防误删+过期+续期锁版本

6.0Hset自旋+防误删+过期+续期+可重入锁版本

1.0原始版本

本版本中我们将介绍一个非分布式的锁的功能。我们将假设多个线程将抢占一个锁，并对一个Redis中的String类型进行互斥更改。

@RestController
@RequestMapping("/lock")
public class Lock_String {
    @Autowired
    StringRedisTemplate stringRedisTemplate;
    private static final String KEY = "Number1";
    private static final Lock lock = new ReentrantLock();

    @GetMapping("/inc")
    public String addOne() {
        //上锁
        lock.lock();
        String result1 = null;
        String result2 = null;
        try {
            //1 访问redis中资源
            result1 = stringRedisTemplate.opsForValue().get(KEY);
            //2 更改数值
            stringRedisTemplate.opsForValue().set(KEY, String.valueOf(Integer.parseInt(result1) + 1));
            //3 检测资源是否更改
            result2 = stringRedisTemplate.opsForValue().get(KEY);
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } finally {
            //解锁
            lock.unlock();
        }
        return "数值从" + result1 + "变更为" + result2;
    }
}

2.0Setnx自旋锁版本

实现功能：理想情况下互斥

@RestController
@RequestMapping("/lock")
public class lock2_0 {
    @Autowired
    StringRedisTemplate stringRedisTemplate;

    private static final String KEY_RES = "Number1";
    private static final String KEY_LOCK = "Lock";
    private final String VALUE_LOCK = UUID.randomUUID() + ":" + Thread.currentThread().getId();

    @GetMapping("/inc")
    public String addOne() {
        //加锁
        lock();
        String result1 = null;
        String result2 = null;

        try {
            //1 访问redis中资源
            result1 = stringRedisTemplate.opsForValue().get(KEY_RES);
            //2 增加该资源
            stringRedisTemplate.opsForValue().set(KEY_RES, String.valueOf(Integer.parseInt(result1) + 1));
            //3 检测资源是否更改
            result2 = stringRedisTemplate.opsForValue().get(KEY_RES);
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } finally {
            //解锁
            unlock();
        }
        return "数值从" + result1 + "变更为" + result2;
    }

    private void lock() {
        System.out.println(VALUE_LOCK);
        while (!stringRedisTemplate.opsForValue().setIfAbsent(KEY_LOCK, VALUE_LOCK)) {
            //暂停20毫秒，自旋
            try {
                TimeUnit.MILLISECONDS.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void unlock() {
        stringRedisTemplate.delete(KEY_LOCK);
    }
}

目前存在问题：由于是分布式架构，stringRedisTemplate.delete(KEY_LOCK);语句向redis发送的命令可能会由于网络问题丢失，也可能是java微服务崩溃，进而导致该锁始终无法解除。

改进方案：为锁设置过期时间。

3.0Setnx自旋+过期锁版本

目前实现功能：到期锁自动过期。

private static final int expiredTime = 30;
private void lock() {
    System.out.println(VALUE_LOCK);
    while (!stringRedisTemplate.opsForValue().setIfAbsent(KEY_LOCK, VALUE_LOCK)) {
    stringRedisTemplate.expire(key,expiredTime,TimeUnit.SECONDS);//添加过期时间
        //暂停20毫秒，自旋
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

存在问题：

  • 更改过期时间问题：可能expire语句和del语句一样由于网络问题丢失，导致该锁还是无法解除。
    • 改进思路：加锁时原子性设置过期时间。

3.1Setnx自旋+过期plus锁版本

private void lock() {
    System.out.println(VALUE_LOCK);
    while (!stringRedisTemplate.opsForValue().setIfAbsent(KEY_LOCK, VALUE_LOCK, expiredTime, TimeUnit.SECONDS)) {//原子性添加过期时间
        //暂停20毫秒，自旋
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

存在问题：

  • 误删问题：如果业务处理过慢导致del语句在到期后再执行，会导致删除其他线程的锁。
    • 改进思路：删除时使用Lua脚本添加判断逻辑，同时保证原子性（如果不保证原子性，会导致和上面一样的问题）。

4.0Setnx自旋+防误删+过期锁版本

private void unlock() {
    String LuaScript =
            "if (redis.call('get',KEYS[1]) == ARGV[1]) then " +//如果KEY_LOCK的value就是当前线程的uuid
                    "return redis.call('del',KEYS[1]) " +//说明就是当前线程的锁，进行删除
                    "else " +//否则不删除
                    "return 0 " +
                    "end";
    stringRedisTemplate.execute(new DefaultRedisScript<>(LuaScript, Boolean.class), Arrays.asList(KEY_LOCK), VALUE_LOCK);
}

存在问题：

  • 正常情况下锁过期：可能业务处理过慢，导致业务没处理完锁就过期了。
    • 改进思路：另起一个线程，定期将锁的时间延长。（保证在未宕机的情况下锁不会过期，并且依旧不会让锁无法释放）

5.0Setnx自旋+防误删+过期+续期锁版本

private void lock() {
    System.out.println(VALUE_LOCK);
    while (!stringRedisTemplate.opsForValue().setIfAbsent(KEY_LOCK, VALUE_LOCK, expiredTime, TimeUnit.SECONDS)) {
        //暂停20毫秒，自旋
        try {
            TimeUnit.MILLISECONDS.sleep(20);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
    renewal();
}
private void renewal() {
    String script =
            "if (redis.call('get',KEYS[1]) == ARGV[1]) then " +//如果KEY_LOCK的value就是当前线程的uuid
                    "return redis.call('expire',KEYS[1],ARGV[2]) " +说明就是当前线程的锁，进行续期
                    "else " +
                    "return 0 " +//否则返回0并退出
                    "end";
    new Thread(() -> {
        while (Boolean.TRUE.equals(stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(KEY_LOCK), VALUE_LOCK, String.valueOf(expiredTime)))) {
            System.out.println("重续");
            try {
                Thread.sleep(expiredTime*1000/3);//执行成功就睡1/3个过期时间，不成功说明已经被解锁或已经过期了，就停止该线程。
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }).start();

存在问题：并不存在什么大问题了，只是不支持可重入锁，其实不怎么必需（go就不支持重入锁），但是为了让这个锁更加方便使用，还是实现一下可重入功能。

改进思路：在原先Lock-Key、Lock-Value的基础上，添加一个int值用于记录重入次数，并且使用Lua脚本重新实现lock、unlock、renewal函数的对应逻辑。

6.0Hset自旋+防误删+过期+续期+可重入锁版本

在Hset中存储：Lock-Key：Lock-Value：Lock-time s。

@RestController
@RequestMapping("/lock2")
public class Lock_Hash {
    @Autowired
    StringRedisTemplate stringRedisTemplate;

    private static final String KEY_RES = "Number1";
    private static final String KEY_LOCK = "Lock";
    private final String VALUE_LOCK = UUID.randomUUID() + ":" + Thread.currentThread().getId();
    private static final int expiredTime = 30;

    @GetMapping("/inc")
    public String addOne() {
        //加锁
        lock();
        String result1 = null;
        String result2 = null;

        try {
            //1 访问redis中资源
            result1 = stringRedisTemplate.opsForValue().get(KEY_RES);
            //2 增加该资源
            stringRedisTemplate.opsForValue().set(KEY_RES, String.valueOf(Integer.parseInt(result1) + 1));
            //3 检测资源是否更改
            result2 = stringRedisTemplate.opsForValue().get(KEY_RES);
            //4 测试重入方法
            reEnter();
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } finally {
            //解锁
            unlock();
        }
        return "数值从" + result1 + "变更为" + result2;
    }

    private void reEnter() {
        //加锁
        lock();
        String result1 = null;
        try {
            //1 访问redis中资源
            result1 = stringRedisTemplate.opsForValue().get(KEY_RES);
            //2 偷偷再+1
            stringRedisTemplate.opsForValue().set(KEY_RES, String.valueOf(Integer.parseInt(result1) + 1));
        } catch (NumberFormatException e) {
            e.printStackTrace();
        } finally {
            //解锁
            unlock();
        }
    }

    private void lock() {
        String LuaScript =
                "if redis.call('exists',KEYS[1]) == 0 or redis.call('hexists',KEYS[1],ARGV[1]) == 1 then " +//不存在说明锁未被抢占；存在则判断锁是否是自己的锁
                        "redis.call('hincrby',KEYS[1],ARGV[1],1) " +//自己的锁或未抢占锁则重入次数加1，并重置或设置锁过期时间
                        "redis.call('expire',KEYS[1],ARGV[2]) " +
                        "return 1 " +
                        "else " +
                        "return 0 " +
                        "end";
        while (!stringRedisTemplate.execute(new DefaultRedisScript<>(LuaScript,Boolean.class), Arrays.asList(KEY_LOCK),VALUE_LOCK,String.valueOf(expiredTime))) {
            //暂停20毫秒，自旋
            try {
                TimeUnit.MILLISECONDS.sleep(20);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        renewal();
    }

    private void unlock() {
        String LuaScript =
                "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 0 then " +//锁不存在说明已过期
                        "   return nil " +
                        "elseif redis.call('HINCRBY',KEYS[1],ARGV[1],-1) == 0 then " +//否则将重入值-1，如果重入值为到达0，说明释放锁，将锁删除
                        "   return redis.call('del',KEYS[1]) " +
                        "else " +
                        "   return 0 " +
                        "end";
        Long flag = stringRedisTemplate.execute(new DefaultRedisScript<>(LuaScript, Long.class), Arrays.asList(KEY_LOCK),VALUE_LOCK,String.valueOf(expiredTime));
        if(flag == null)
        {
            throw new RuntimeException("This lock doesn't EXIST");
        }
    }

    private void renewal() {
        String script =
                "if redis.call('HEXISTS',KEYS[1],ARGV[1]) == 1 then " +//如果KEY_LOCK的value就是当前线程的uuid
                        "return redis.call('expire',KEYS[1],ARGV[2]) " +说明就是当前线程的锁，进行续期
                        "else " +
                        "return 0 " +//否则返回0并退出
                        "end";
        new Thread(() -> {
            while (Boolean.TRUE.equals(stringRedisTemplate.execute(new DefaultRedisScript<>(script, Boolean.class), Arrays.asList(KEY_LOCK), VALUE_LOCK, String.valueOf(expiredTime)))) {
                try {
                    Thread.sleep(expiredTime * 1000 / 3);//执行成功就睡1/3个过期时间，不成功说明已经被解锁或已经过期了，就停止该线程。
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }
}

其他改进点：如实现JUC的Lock接口；使用简单工厂模式等，这里就不做赘述了。

到这分布式锁已经写得差不多了，不过还是有一个绕不过的点，就是都是单实例的锁，要求redis的master不会宕机。接下来就需要使用Redlock来改进这个问题，具体请查看后续文章。

寿命齿轮
关注
专栏目录
SpringBoot系列之基于Jedis实现分布式锁
Nicky's blog
12-12 673
Redis系列之基于Jedis实现分布式锁。在单机环境，我们使用最多的是juc包里的单机锁，但是随着微服务分布式项目的普及，juc里的锁是不能控制分布锁环境的线程安全的，因为单机锁只能控制同个进程里的线程安全，不能控制多节点的线程安全，所以就需要使用分布式锁
Spring Boot Redis实现分布式锁，真香！！
07-16 421
免费学习视频欢迎关注云图智联：https://e.yuntuzhilian.com/ 之前看很多人手写分布式锁，其实 Spring Boot 现在已经做的足够好了，开箱即用，支持主流的 Redis、Zookeeper 中间件，另外还支持 JDBC。 本篇栈长以 Redis 为例（这也是用得最多的方案），教大家如何利用 Spring Boot 集成 Redis 实现缓存，如何简单、快速实现 Redis 分布式锁。 分布式锁介绍 Spring Boot 实现 Redis 分布式锁在 spring-int
基于 RedisTemplate + 线程池 实现 Redis分布式锁（含模板、带图文、代码段示例引导）
programming132的博客
02-24 5568
了解 Redis 分布式锁实现方式，性能优化等。（带图文、代码）解析示例，学习Redis分布式锁执行流程。包含最终代码模板。
分布式锁之Redis篇
qq_44209336的博客
12-08 386
分布式锁之Redis 文章目录分布式锁之Redis1. 前言2. Redis实现分布式锁2.1 阶段一2.2 阶段二2.3 阶段三2.4 阶段四2.5 阶段五2.6 小总结3. Redisson实现分布式锁3.1 Redisson 简介3.2 可重入锁 Reentrant Lock3.3 读写锁 ReadWriteLock3.4 信号量 Semaphore3.5 闭锁 CountDownLatch3.6 Redisson解决上面Redis查询问题 1. 前言 在Java并发编程中，我们通常使用到synch
手写一个Redis分布式锁解决实际开发中高并发问题
星悬_月的博客
04-01 223
手写一个Redis分布式锁解决实际开发中高并发问题 文章目录 场景搭建环境1. 导入依赖2. 配置连接redis3. 编写接口4. 编写业务类5. 准备测试 分析解决问题若是不加任何更改，直接使用上述业务代码使用 synchronized 关键字分布式架构下的问题问题1问题2问题3 总结 场景 多线程高并发卖票问题想必都不陌生，那么如何解决票的超卖问题呢？ 接下来我们来一步一步分析 开始之前，先搭建好测试环境
手写Redis分布式锁
最新发布
xiaguxiagu的博客
05-08 1612
手写Redis分布式锁
手写一个基于redis的分布式锁
coderyjz的博客
12-16 1332
基于redis的分布式锁 一、为什么要做 无疑，关于分布式锁，我们都已比较熟悉，网上有较多的开源解决方案，如redis的redisson，以及zookeeper的curator等，关于这两种分布式锁的使用及原理，后期会写文章介绍。本文主要针对小白，分享一下我学习分布式锁的一些心得，如果是大神请留下您的宝贵意见。 二、俯视代码 关于代码，我写的比较精简，力争在保证功能的情况下让使用上变得更加...
分布式锁之redis锁--手写redis
xiaozhu0301的博客
12-18 219
分布式锁，即同一个服务被部署成集群，这样就涉及到资源争抢的问题，单机的资源，直接用jvm内部的synchronized的锁就可以 分布式锁的接口 package com.online.taxi.order.service; public interface GrabService { /** * 司机抢单 * @param orderId * @param driverId * @return */ public String g
【Redis】分布式锁
flora
02-03 274
Redis分布式锁为什么要用分布式锁基于Redis的分布式锁RedissiontryLock（）unLock（）watch dog 自动延期 为什么要用分布式锁 如果原本我们的系统分布在一台机器上的时候，JVM提供的锁就能解决并发问题。但是如果我们是使用多台机器，要同时去Redis里面去拿同一个Key 这个时候，就会发生并发问题，因为这个时候JVM的锁事无 法解决这个问题。 基于Redis的分布式锁 加锁：最简单的方法是使用setnx 命令，Key 是锁的唯一标识 setnx key value ：是去
Redis分布式锁
vincentchen1990的博客
10-10 180
一、悲观锁 使用redis实现分布式悲观锁，主要是使用了redis原生命令的set命令（http://redisdoc.com/string/set.html）， SET key value [EX seconds] [PX milliseconds] [NX|XX] 从 Redis 2.6.12 版本开始， SET 命令的行为可以通过一系列参数来修改，比如NX参数，就能取代SETNX命令...
Redis分布式锁、内存淘汰策略
weixin_51360664的博客
08-06 253
Redis分布式锁、内存淘汰策略
redis 分布式锁
weixin_58361879的博客
06-20 876
redis手写分布式锁
用C++手写redis分布式锁
08-19
手写Redis分布式锁的一个常见方法是使用Redis的SETNX命令和EXPIRE命令。SETNX用于设置一个键值对，只有在键不存在的情况下才能设置成功，用于表示获取锁的操作。EXPIRE用于设置键的过期时间，确保在获取锁的客户端...
基于redis手写一个分布式锁
weixin_44032502的博客
12-26 653
基于redis手写一个分布式锁简介一、分布式锁原理二、java实现redis的分布式锁三、使用redisson实现分布式锁 简介 分布式锁，名字就看的出来是应用于分布式系统中的锁，我们平时熟知的synchronized等一系列锁是在一个jvm内实现的，而很多大型的系统通常都是采用分布式部署开发，不在一个jvm内运行所以synchronized等锁就失效了，分布式锁就是解决分布式系统中锁的问题，下面我们来手写一个基于redis的分布式锁来了解一下分布式锁的原理。本文源码地址：https://github.co
redis实现分布式锁,自旋式加锁,lua原子性解锁
tiantangpw的专栏
07-16 636
手动实现的redis分布式锁
Redis分布式锁如何自动续期
一江溪水
11-27 5140
Redis 实现分布式锁 指定一个 key 作为锁标记，存入 Redis 中，指定一个 唯一的用户标识作为 value。 当 key 不存在时才能设置值，确保同一时间只有一个客户端进程获得锁，满足互斥性特性。 设置一个过期时间，防止因系统异常导致没能删除这个 key，满足防死锁特性。 当处理完业务之后需要清除这个 key 来释放锁，清除 key 时需要校验 value 值，需要满足只有加锁的人才能释放锁 。 问题 如果这个锁的过期时间是30秒，但是业务运行超过了30秒，比如40秒，当业务运行到30秒的时
redis分布式锁（手写）--尚硅谷分布式锁教程笔记
qq_60313016的博客
09-08 949
手写redis分布式锁的思考过程，通俗易懂
分布式锁其实很简单，6行代码教你实现redis分布式锁，千万不要再用redisTemplate写redis分布式锁代码实现
小小鱼儿小小林的博客
10-29 6939
分布式锁是一种用于协调分布式系统中多个节点之间对共享资源进行访问控制的机制。它可以确保在分布式环境下，同一时间只有一个节点能够获取到锁，并且其他节点需要等待释放锁后才能获取。以下是使用分布式锁的几个常见场景和原因：避免资源冲突：当多个节点需要同时对共享资源进行读写操作时，使用分布式锁可以确保同一时间只有一个节点能够执行写操作，避免数据冲突和一致性问题。防止重复处理：在某些业务场景中，可能会出现重复处理的问题，例如订单支付、秒杀等。
第十九章_手写Redis分布式锁
sinat_31583645的博客
06-01 922
在目标锁对象的计数器不为零的情况下，如果锁对象的持有线程是当前线程，那么 Java 虚拟机可以将其计数器加1，否则需要等待，直至持有线程释放该锁。是指在同一个线程在外层方法获取锁的时候，再进入该线程的内层方法会自动获取锁(前提，锁对象得是同一个对象)，不会因为之前已经获取过还没释放而阻塞。不同进程jvm层面的锁就不管用了，那么可以利用第三方的一个组件，来获取锁，未获取到锁，则阻塞当前想要运行的线程。指的是可重复可递归调用的锁，在外层使用锁之后，在内层仍然可以使用，并且不发生死锁，这样的锁就叫做可重入锁。
SpringBoot+Redis：详解分布式锁实战与setnx实现
本文主要介绍了如何在SpringBoot项目中正确地集成Redis来实现分布式锁。分布式锁在分布式系统中扮演着关键角色，尤其是在高并发场景下，能够避免并发问题导致的数据不一致。作者分享了一个具体的实践案例，涉及到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值