深入浅出分布式锁

已于 2023-02-15 11:29:16 修改
阅读量1.3k 收藏 1
点赞数
分类专栏： 理论&实践 文章标签： redis
于 2022-03-14 15:41:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37151886/article/details/123471159
版权

参考

深度剖析：Redis分布式锁到底安全吗？看完这篇文章彻底懂了！

尚硅谷2022最新版分布式锁系列视频

快速上手

三种实现

redis、zookeeper、数据库（MySQL）

JMeter

深入浅出Apache JMeter

redis

本地Redis中模拟库存扣减的过程。
在这里插入图片描述

版本一

    @GetMapping("sell")
    public String sell() {
        int sell = Integer.parseInt(stringRedisTemplate.opsForValue().get("sell"));
        if (sell > 0) {
            int realStock = sell - 1;
            stringRedisTemplate.opsForValue().set("sell", realStock + "");
            System.out.println(port + ":扣除成功，剩余库存" + realStock);
        } else {
            System.out.println(port + ":扣减失败，库存不足");
        }
        return port + "end";
    }

在这里插入图片描述
出现了重复扣减，我们进行改进。

版本二

    @GetMapping("sell2")
    public String sell2() {
        synchronized (this) {
            int sell = Integer.parseInt(stringRedisTemplate.opsForValue().get("sell"));
            if (sell > 0) {
                int realStock = sell - 1;
                stringRedisTemplate.opsForValue().set("sell", realStock + "");
                System.out.println(port + ":扣除成功，剩余库存" + realStock);
            } else {
                System.out.println(port + ":扣减失败，库存不足");
            }
            return port + "end";
        }
    }

在这里插入图片描述
synchronized 无法跨jvm进行锁定，当有多台机器时，需要使用分布式锁来保证其正确性。

版本三

使用 Redis 的 setIfAbsent
在这里插入图片描述

public String sell3() {
        String lock = "lock";
        //加锁
        Boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lock, "this is lock");
        if (result) {
            int sell = Integer.parseInt(stringRedisTemplate.opsForValue().get("sell"));
            if (sell > 0) {
                int realStock = sell - 1;
                stringRedisTemplate.opsForValue().set("sell", realStock + "");
                System.out.println(port + ":扣除成功，剩余库存" + realStock);
            } else {
                System.out.println(port + ":扣减失败，库存不足");
            }
            //删除锁
            stringRedisTemplate.delete(lock);
            return port + "end";
        }
        return "获取锁错误";
    }

加锁部分如果出现异常会导致锁无法释放。

版本四

使用 try catch来保证程序内异常仍然可以释放锁。

    public String sell4() {
        String lock = "lock";
        try {
            boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lock, "this is lock");
            if (result) {
                int sell = Integer.parseInt(stringRedisTemplate.opsForValue().get("sell"));
                if (sell > 0) {
                    int realStock = sell - 1;
                    stringRedisTemplate.opsForValue().set("sell", realStock + "");
                    System.out.println(port + ":扣除成功，剩余库存" + realStock);
                } else {
                    System.out.println(port + ":扣减失败，库存不足");
                }
            } else {
                return port + "获取锁错误";
            }
        } finally {
            stringRedisTemplate.delete(lock);
        }
        return port + "end";
    }

虽然程序内异常可以屏蔽，但是如果强制结束进程仍会造成死锁。

版本五 增加过期时间

注意事项：加锁的动作应该是原子性操作，如果分为两步，在第一步结束后宕机仍然存在死锁的问题。

 boolean result = stringRedisTemplate.opsForValue()
 .setIfAbsent(lock, "this is lock", 30, TimeUnit.SECONDS);

假设过期时间为10s，业务执行10.1s，存在误删除别人锁的情况。

版本六 增加唯一标识

通过 uuid 来确保删除前判断是否自己持有锁。

    @GetMapping("sell6")
    public String sell6() {
        String lock = "lock";
        String uuid = UUID.randomUUID().toString();
        try {
            boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lock, uuid, 10, TimeUnit.SECONDS);
            if (result) {
                int sell = Integer.parseInt(stringRedisTemplate.opsForValue().get("sell"));
                if (sell > 0) {
                    int realStock = sell - 1;
                    stringRedisTemplate.opsForValue().set("sell", realStock + "");
                    System.out.println(port + ":扣除成功，剩余库存" + realStock);
                } else {
                    System.out.println(port + ":扣减失败，库存不足");
                }
            } else {
                return port + "获取锁错误";
            }
        } finally {
            if (uuid.equals(stringRedisTemplate.opsForValue().get(lock))) {
                //
                //
                stringRedisTemplate.delete(lock);
            }
        }
        return port + "end";
    }

由于删除锁不是原子性，所以删除锁错误代码如下所示

//线程一
if (uuid.equals(stringRedisTemplate.opsForValue().get(lock))) {
//锁到期了
//线程二
stringRedisTemplate.opsForValue().setIfAbsent(lock, uuid, 10, imeUnit.SECONDS);
//线程一
stringRedisTemplate.delete(lock);
}

版本七 使用lua脚本释放锁 （原子性）

查询key对应的值，如果和uuid相等删除key，否则结束操作。

del.lua

local key = KEYS[1]
local val = redis.call('GET',key)
if val == ARGV[1]
then
redis.call('DEL', KEYS[1])
return 1
else
return 0
end

RedisScriptConfig.java

@Configuration
public class RedisScriptConfig {

    @Bean
    public DefaultRedisScript<Boolean> redisScript() {
        DefaultRedisScript<Boolean> script = new DefaultRedisScript<>();
        ClassPathResource classPathResource = new ClassPathResource("lua/del.lua");
        ResourceScriptSource resourceScriptSource = new ResourceScriptSource(classPathResource);
        script.setResultType(Boolean.class);
        script.setScriptSource(resourceScriptSource);
        return script;
    }
}

    @GetMapping("sell7")
    public String sell7() {
        String lock = "lock";
        String uuid = UUID.randomUUID().toString();
        try {
            boolean result = stringRedisTemplate.opsForValue().setIfAbsent(lock, uuid, 10, TimeUnit.SECONDS);
            if (result) {
                int sell = Integer.parseInt(stringRedisTemplate.opsForValue().get("sell"));
                if (sell > 0) {
                    int realStock = sell - 1;
                    stringRedisTemplate.opsForValue().set("sell", realStock + "");
                    System.out.println(port + ":扣除成功，剩余库存" + realStock);
                } else {
                    System.out.println(port + ":扣减失败，库存不足");
                }
            } else {
                return port + "获取锁错误";
            }
        } finally {
            List<String> keys = Collections.singletonList(lock);
            stringRedisTemplate.execute(redisScript, keys, uuid);
        }
        return port + "end";
    }

仔细思考一下，锁的过期时间要充分冗余，避免提前过期的风险。

版本八 redisson

pom依赖

 <!-- https://mvnrepository.com/artifact/org.redisson/redisson -->
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson</artifactId>
            <version>3.16.8</version>
        </dependency>

RedissionConfig

@Configuration
public class RedissionConfig {

    @Value("${spring.redis.host}")
    private String host;

    @Value("${spring.redis.port}")
    private String port;

    @Value("${spring.redis.password}")
    private String password;

    @Bean
    public RedissonClient redissonClient() {
        Config config = new Config();
        if (ObjectUtils.isEmpty(password)){
            config.useSingleServer().setAddress("redis://" + host + ":" + port);
        }
        else{
            config.useSingleServer().setAddress("redis://" + host + ":" + port).setPassword(password);
        }
        return Redisson.create(config);
    }
}

controller

    @Autowired
    private RedissonClient redissonClient;

    @GetMapping("sell9")
    public String sell9() {
        //获取锁
        RLock rLock = redissonClient.getLock("lock");
        try {
            //加锁
            rLock.lock();
            int sell = Integer.parseInt(stringRedisTemplate.opsForValue().get("sell"));
            if (sell > 0) {
                int realStock = sell - 1;
                stringRedisTemplate.opsForValue().set("sell", realStock + "");
                System.out.println(port + ":扣除成功，剩余库存" + realStock);
            } else {
                System.out.println(port + ":扣减失败，库存不足");
            }

        } finally {
            //解锁
            rLock.unlock();
        }
        return port + "end";
    }

版本九 自旋

redisson同样为我们提供了自旋机制

        RLock rLock = redissonClient.getSpinLock(lock);

自旋和非自旋的区别

redis作为分布式锁的主要问题

过期时间、原子性、唯一标识、异常等问题。

redis集群存在的问题

当 redis 处于集群的时候会存在各种各样的极端情况，对于资源绝对正确的业务，仍需要采取其他手段来保证数据正确，也就是不能认为redis做分布式锁是一定可靠的。

Zookeeper （一致性）

Spring Boot使用Zk实现分布式锁

引入 Apache Curator

Apache Curator 是分布式协调服务Apache ZooKeeper的 Java/JVM 客户端库。它包括一个高级 API 框架和实用程序，使 Apache ZooKeeper 的使用更加轻松和可靠

Apache Curator

        <!-- https://mvnrepository.com/artifact/org.apache.curator/curator-recipes -->
        <dependency>
            <groupId>org.apache.curator</groupId>
            <artifactId>curator-recipes</artifactId>
            <version>5.2.1</version>
        </dependency>

新建配置类负责连接Zk

@Configuration
public class ZkCuratorRecipesConfig {

    @Bean
    public CuratorFramework getZkClient() throws InterruptedException {
        String zkAddr = "192.168.17.128:2181";
        RetryPolicy retryPolicy = new ExponentialBackoffRetry(1000, 3);
        CuratorFramework client = CuratorFrameworkFactory.newClient(zkAddr, retryPolicy);
        client.start();
        return client;
    }
}

    @Autowired
    CuratorFramework client;

    @GetMapping("b")
    public void b() throws Exception {
        InterProcessMutex lock = new InterProcessMutex(client, "/lock");
        if (lock.acquire(1, TimeUnit.SECONDS)) {
            try {
                logger.info("{} , {} ", Thread.currentThread().getName(), "获取到锁");
            } finally {
                lock.release();
            }
        }
    }

在这里插入图片描述
稍微改造一下接口进行压测

@GetMapping("c")
    public void c() throws Exception {
        InterProcessMutex lock = new InterProcessMutex(client, "/lock");
        String tName = Thread.currentThread().getName();
        if (lock.acquire(1, TimeUnit.SECONDS)) {
            try {
                logger.info("{} , {} ", tName, "获取到锁");
                Thread.sleep(500);
            } finally {
                lock.release();
                logger.info("{} , {} ", tName, "释放锁");
            }
        }
    }

效果图如下
在这里插入图片描述

原理分析

在这里插入图片描述

长时间没有收到心跳，zk会删除临时节点。

zk绝对安全吗

在这里插入图片描述
可以看到极端情况下，zk也有极小概率冲突。

数据库

以 MySQL为例

基于 MySQL 唯一索引的分布式锁

insert 和 delete

建一张分布式锁表，通过写入和删除数据来实现分布式锁。

悲观锁

利用for update语句。适用场景：写多读少。存在锁表风险。

乐观锁

利用 version 版本号。适用场景：读多写少。

选型和总结

侧重性能和简单使用Redis。
侧重安全性使用zookeeper。
记住极端情况互斥性都会被打破，不要认为绝对可靠。
数据库来做分布式锁会有性能瓶颈。

高并发下分布式锁优化

优化思想：锁分段、读写锁、无锁。

newProxyInstance
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
浅析分布式锁
Huangjiazhen711的博客
11-08 285
单体应用下共享资源的操作需要使用本地锁（synchronized、reentrantLock），来控制共享资源访问问题。。通常把锁和应用分开部署，把这个锁做成公共组件，多个应用多个节点去访问这个组件，来解决共享资源的访问。
彻底弄清楚分布式锁
l688899886的博客
08-11 105
关于实现强一致性的手段，可以使用多种方式来进行实现，有，有，还有等等，那么这篇文章我们就围绕分布式锁这个话题来进行展开，首先，我们会先探究它的原理，然后结合实际应用，对目前较为常见的分布式锁实现方式及注意事项进行详细的分析。...
redis分布式锁实现方案深入探讨（锁重试、锁续租、Redis Module、Redisson、RedLock）
你学废了吗？
05-17 2746
codis 没有pub/sub功能，如果想使用监听+远程唤醒的功能，需要用redis cluster 用zk和etcd实现的分布式锁，都可以使用watcher机制。 但是redis cluster、zk、etcd v2 的发布订阅都会存在惊群效应，一个事件变更，如果有大量的客户端监听，需要一个个远程通知，对这些集群的负载影响很大。 etcd v3，实现了类似java的AQS的clh，有多个监听会形成一个链表，不会一下子唤醒，而是依托前驱唤醒后继。
redis---分布式锁存在的问题及解决方案（Redisson）
热门推荐
池海
04-01 1万+
系列文章目录 提示：这里可以添加系列文章的所有文章的目录，目录需要自己手动添加 例如：第一章 Python 机器学习入门之pandas的使用 提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录系列文章目录前言一、pandas是什么？二、使用步骤1.setNx2.set NX NP3.锁超时问题3.1过期时间如何设置3.2锁的续签4.增加锁的可重入性2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人
MySQL唯一索引实现分布式锁
weixin_42002747的博客
03-31 495
数据库表结构 加锁操作 1）开启事务； 2）插入一行记录； 3）执行业务代码； 解锁操作 1）回滚； 优点： 1）数据库不会浪费任何空间； 2）客户端挂了没有进行回滚操作，数据库也会自动释放锁； 缺点： 1）数据库实现的分布式锁只能是非公平锁； 2）没有可重入特性，可以在客户端利用ThreadLocal保存锁重入次数； 3）性能较低，因为MySQL最多也就能扛住几千并发，高并发场景下肯定不行，而且是阻塞地获取锁，如果要实现非阻塞，可以不用事务，加锁直接插入记录，解锁删除记录，但是会出现客户端挂了没有删除记
分布式锁的应用场景与分布式锁实现（四）：基于MySQL实现分布式锁与分布式锁总结
ruozhuliufeng的博客
06-01 616
基于MySQL实现分布式锁，以及本系列分布式锁的总结
分布式锁的实现- mysql
ajun_studio的专栏
08-26 2524
大家好，我是飓风，今天我们来聊聊分布式锁的原理、以及基于 mysql 怎么来实现分布式锁。那么大家现在能不能想一想，分布式锁的使用场景都有哪些呢？下面我列举一些分布式锁的场景：记住一点，一定是在分布式的环境下，所以肯定是多个服务，或者多个进程来操作一个共享资源。扣减库存订单支付，检查订单是否进行了重复支付的操作缓存击穿/缓存雪崩，防止大并发对 DB 的操作。......
187深入浅出分布式技术原理
05-05
本资料“187深入浅出分布式技术原理”旨在帮助读者理解分布式系统的精髓，掌握如何设计和实现高效、可靠的分布式系统。 分布式技术的核心理念在于将任务分解到多个独立的节点上，以实现并行处理，提高系统的性能和...
深入浅出分布式技术原理 教程 下载 下载4.zip
06-20
本教程“深入浅出分布式技术原理”旨在帮助读者理解并掌握这一核心技术，通过学习，您可以深入了解分布式系统的设计、实现以及优化策略。 分布式技术的核心目标在于提高系统的可伸缩性、容错性和性能。它包括多个子...
深入浅出Zookeeper（二）基于Zookeeper的分布式锁与领导选举
03-03
本文来自于技术世界，本文结合实例演示了使用Zookeeper实现分布式锁与领导选举的原理与具体实现方法。如上文《Zookeeper架构及FastLeaderElection机制》所述，Zookeeper提供了一个类似于Linux文件系统的树形结构。该...
深入浅出分布式技术原理 教程 下载 下载3.zip
06-20
"深入浅出分布式技术原理教程"旨在帮助读者理解和掌握分布式系统的基础知识和实践应用。本教程可能涵盖了以下关键知识点： 1. 分布式系统概念：分布式系统是由多台计算机通过网络连接，共同协作完成一个单一的任务...
深入浅出分布式技术原理 教程 下载 下载1.zip
06-20
本教程“深入浅出分布式技术原理”旨在帮助读者理解和掌握分布式系统的概念、设计原则以及实际应用。 分布式系统的核心是将单一复杂的任务分解为多个可并行处理的部分，这些部分可以在不同的硬件或软件节点上运行。...
一文详解如何用 MySQL/Redis/ZooKeeper 实现分布式锁
m0_73311735的博客
10-18 1359
假如我们设置锁过期时间是 6 秒，正常情况下业务逻辑可以在 6 秒内处理完成，但是当 JVM 发生 FullGC 或者调用第三方服务出现网络延迟，业务逻辑还没处理完，锁已经过期，被删掉，然后被其他线程获取到锁，岂不是要出问题？获取锁的同时，启动一个异步任务，每当业务执行到三分之一时间，也就是 6 秒中的第 2 秒的时候，就自动延长锁过期时间，继续延长到 6 秒，这样就能保证业务逻辑处理完成之前锁不会过期。，如果业务处理失败或者机器宕机，导致没有释放锁，锁就会一直存在，其他线程也无法获取到锁。
一种基于mysql实现分布式锁的方式
heouheou的博客
03-26 927
分布式锁，即分布式系统中的锁。在单体应用中我们通过锁解决的是控制共享资源访问的问题，而分布式锁，就是解决了分布式系统中控制共享资源访问的问题。与单体应用不同的是，分布式系统中竞争共享资源的最小粒度从线程升级成了进程。目前比较常见的实现分布式锁的方式主要有三种：基于数据库实现、基于Zookeeper实现、基于redis实现。本文主要介绍了一种基于mysql数据库实现分布式锁的方式，从最简单的实现方式开始，一步步构造一个拥有基本分布式锁条件的程序。
Jmeter 性能-死锁问题定位+分析
人生不怕起点低，就怕没追求
11-10 78
1、环境搭建 ①准备脚本，执行压测②用Jstack 打印日志③下载日志到本地
jmeter临界部分控制器介绍
m0_56039243的博客
02-17 1176
jmeter临界部分控制器介绍
Redisson实现Redis分布式锁的N种姿势
weixin_33968104的博客
12-03 2698
前几天发的一篇文章《Redlock：Redis分布式锁最牛逼的实现》，引起了一些同学的讨论，也有一些同学提出了一些疑问，这是好事儿。本文在讲解如何使用Redisson实现Redis普通分布式锁，以及Redlock算法分布式锁的几种方式的同时，也附带解答这些同学的一些疑问。 Redis几种架构 Redis发展到现在，几种常见的部署架构有： 单机模式； ...
Redis初识
最新发布
qq_61422622的博客
07-17 920
为了明确分布式系统，我们先来了解单机架构，那么什么是单机架构呢？所谓的单机架构，即只有一台服务器，这个服务器负责所有的工作。如上图一个简单的电商网站的组成，有一个单机服务器完成所有功能，单机服务器主要用有两个服务一个是应用服务（服务端程序），一个是数据库服务（数据存储）。此时一台主机能满足业务需求，这就是单价架构。但是我们一台主机上的硬件资源是有限的，当同一时刻处理的请求多了，就可能会导致某个硬件资源不够用了，从而导致访问时间变长，甚至出错，一般遇到这种场景我们会进行优化：开源节流，软件上的优化。
Redis分布式锁实战：SpringBoot+Jedis模拟抢单场景
这份文档深入浅出地介绍了如何在实际项目中应用分布式锁，特别是在高并发的抢单场景下。它不仅提供了使用Jedis实现分布式锁的具体步骤，还强调了锁的生命周期管理和原子性操作的重要性，对理解分布式系统中的并发...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值