Redis：18-基于Redis的分布式锁

最新推荐文章于 2024-06-20 18:33:42 发布
最新推荐文章于 2024-06-20 18:33:42 发布
阅读量690 收藏
点赞数
分类专栏： Redis 文章标签： redis 分布式 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_47114547/article/details/127132061
版权

文章目录

一、什么是分布式锁

分布式锁：跨JVM的互斥机制，实现对控制共享资源的访问，一个服务器加锁后对该集群的所有服务器都起作用。

分布式锁主流的实现方案：
（1）基于数据库实现分布式锁
（2）基于缓存（Redis等）
（3）基于Zookeeper

每一种分布式锁解决方案都有各自的优缺点：
（1）性能：redis最高
（2）可靠性：zookeeper最高

这里基于redis实现分布式锁。

二、使用redis实现分布式锁

setnx：set if not exists 的缩写，只有不存在的时候才设置, 设置成功返回 1 ， 设置失败返回 0 。

Redis命令：
EX second ：设置键的过期时间为 second 秒。
PX millisecond ：设置键的过期时间为 millisecond 毫秒。
NX ：只在键不存在时，才对键进行设置操作。
XX ：只在键已经存在时，才对键进行设置操作。

  • 多个客户端同时获取锁（setnx）
  • 获取成功，执行业务逻辑{从db获取数据，放入缓存}，执行完成释放锁（del）
  • 其他客户端等待重试

（1）对键值对设置锁

在这里插入图片描述

若要重新对该键进行设值，先删除该键值，再设置：

在这里插入图片描述

（2）对键设置过期时间
对键设置过期时间后，时间到就会释放该锁，该键值对也就无效了，就可以重新设置键值对了。有两种方法：

①先设置键值在设置过期时间

这种方法当在设置过期时间时出现异常则会导致设置失败，也就是没有对键值设置过期时间，这个键也就一直被锁着。

expire key <seconds>

在这里插入图片描述

②在设置键值时设置过期时间

set key value nx ex <seconds>

在这里插入图片描述

三、代码实现

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;


@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    //分布式锁
    @GetMapping("testLock")
    public void testLock(){
        //1获取锁，setne
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "111");
        //2获取锁成功、查询num的值
        if(lock){
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断num为空return
            if(StringUtils.isEmpty(value)){
                return;
            }
            //2.2有值就转成成int
            int num = Integer.parseInt(value+"");
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num", ++num);
            //2.4释放锁，del
            redisTemplate.delete("lock");

        }else{
            //3获取锁失败、每隔0.1秒再获取
            try {
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //与Redis的操作
    @GetMapping
    public String testRedis() {
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return name;
    }
}

重启，服务集群，通过网关压力测试：

ab -n 1000 -c 100 http://192.168.146.1:8080/redisTest/testLock

四、UUID防止锁被误删

指的是只能释放本键的锁，不能释放其他键的锁。

对以上代码进行修改：
在这里插入图片描述
在这里插入图片描述

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.UUID;

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    //分布式锁
    @GetMapping("testLock")
    public void testLock(){
        //添加UUID防止锁被误删
        String uuid = UUID.randomUUID().toString();

        //1获取锁，setne
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "111");
        //2获取锁成功、查询num的值
        if(lock){
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断num为空return
            if(StringUtils.isEmpty(value)){
                return;
            }
            //2.2有值就转成成int
            int num = Integer.parseInt(value+"");
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num", ++num);
            //2.4释放锁，del
            //先判断比较UUID值是否一样再释放锁
            String lockUuid = (String)redisTemplate.opsForValue().get("lock");
            if(lockUuid.equals(uuid)){
                redisTemplate.delete("lock");
            }
           

        }else{
            //3获取锁失败、每隔0.1秒再获取
            try {
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //与Redis的操作
    @GetMapping
    public String testRedis() {
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return name;
    }
}

五、LUA脚本保证删除的原子性

虽然比较了UUID也是一样的，但是当正要删除本键的锁时，锁恰巧到了过期时间，失效了，而此时另外一个键迅速上锁进行自己的操作，这时本键就误删了另外一个键的锁。可使用LUA脚本解决这个问题。（释放锁就是把键删除掉）

LUA脚本嵌入Java语言中

 //添加LUA脚本保证删除键时的原子性
    @GetMapping("testLockLua")
    public void testLockLua() {
        //1 声明一个uuid ,将做为一个value 放入我们的key所对应的值中
        String uuid = UUID.randomUUID().toString();
        //2 定义一个锁：lua 脚本可以使用同一把锁，来实现删除！
        String skuId = "25"; // 访问skuId 为25号的商品 100008348542
        String locKey = "lock:" + skuId; // 锁住的是每个商品的数据

        // 3 获取锁
        Boolean lock = redisTemplate.opsForValue().setIfAbsent(locKey, uuid, 3, TimeUnit.SECONDS);

        // 第一种： lock 与过期时间中间不写任何的代码。
        // redisTemplate.expire("lock",10, TimeUnit.SECONDS);//设置过期时间
        // 如果true
        if (lock) {
            // 执行的业务逻辑开始
            // 获取缓存中的num 数据
            Object value = redisTemplate.opsForValue().get("num");
            // 如果是空直接返回
            if (StringUtils.isEmpty(value)) {
                return;
            }
            // 不是空 如果说在这出现了异常！ 那么delete 就删除失败！ 也就是说锁永远存在！
            int num = Integer.parseInt(value + "");
            // 使num 每次+1 放入缓存
            redisTemplate.opsForValue().set("num", String.valueOf(++num));
            /*使用lua脚本来锁*/
            // 定义lua 脚本
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            // 使用redis执行lua执行
            DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
            redisScript.setScriptText(script);
            // 设置一下返回值类型 为Long
            // 因为删除判断的时候，返回的0,给其封装为数据类型。如果不封装那么默认返回String 类型，
            // 那么返回字符串与0 会有发生错误。
            redisScript.setResultType(Long.class);
            // 第一个要是script 脚本 ，第二个需要判断的key，第三个就是key所对应的值。
            redisTemplate.execute(redisScript, Arrays.asList(locKey), uuid);
        } else {
            // 其他线程等待
            try {
                // 睡眠
                Thread.sleep(1000);
                // 睡醒了之后，调用方法。
                testLockLua();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

完整代码：

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.core.script.DefaultRedisScript;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.Arrays;
import java.util.UUID;
import java.util.concurrent.TimeUnit;

@RestController
@RequestMapping("/redisTest")
public class RedisTestController {
    @Autowired
    private RedisTemplate redisTemplate;

    //添加LUA脚本保证删除键时的原子性
    @GetMapping("testLockLua")
    public void testLockLua() {
        //1 声明一个uuid ,将做为一个value 放入我们的key所对应的值中
        String uuid = UUID.randomUUID().toString();
        //2 定义一个锁：lua 脚本可以使用同一把锁，来实现删除！
        String skuId = "25"; // 访问skuId 为25号的商品 100008348542
        String locKey = "lock:" + skuId; // 锁住的是每个商品的数据

        // 3 获取锁
        Boolean lock = redisTemplate.opsForValue().setIfAbsent(locKey, uuid, 3, TimeUnit.SECONDS);

        // 第一种： lock 与过期时间中间不写任何的代码。
        // redisTemplate.expire("lock",10, TimeUnit.SECONDS);//设置过期时间
        // 如果true
        if (lock) {
            // 执行的业务逻辑开始
            // 获取缓存中的num 数据
            Object value = redisTemplate.opsForValue().get("num");
            // 如果是空直接返回
            if (StringUtils.isEmpty(value)) {
                return;
            }
            // 不是空 如果说在这出现了异常！ 那么delete 就删除失败！ 也就是说锁永远存在！
            int num = Integer.parseInt(value + "");
            // 使num 每次+1 放入缓存
            redisTemplate.opsForValue().set("num", String.valueOf(++num));
            /*使用lua脚本来锁*/
            // 定义lua 脚本
            String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
            // 使用redis执行lua执行
            DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>();
            redisScript.setScriptText(script);
            // 设置一下返回值类型 为Long
            // 因为删除判断的时候，返回的0,给其封装为数据类型。如果不封装那么默认返回String 类型，
            // 那么返回字符串与0 会有发生错误。
            redisScript.setResultType(Long.class);
            // 第一个要是script 脚本 ，第二个需要判断的key，第三个就是key所对应的值。
            redisTemplate.execute(redisScript, Arrays.asList(locKey), uuid);
        } else {
            // 其他线程等待
            try {
                // 睡眠
                Thread.sleep(1000);
                // 睡醒了之后，调用方法。
                testLockLua();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
    
    //分布式锁
    @GetMapping("testLock")
    public void testLock(){
        //添加UUID防止锁被误删
        String uuid = UUID.randomUUID().toString();

        //1获取锁，setne
        Boolean lock = redisTemplate.opsForValue().setIfAbsent("lock", "111");
        //2获取锁成功、查询num的值
        if(lock){
            Object value = redisTemplate.opsForValue().get("num");
            //2.1判断num为空return
            if(StringUtils.isEmpty(value)){
                return;
            }
            //2.2有值就转成成int
            int num = Integer.parseInt(value+"");
            //2.3把redis的num加1
            redisTemplate.opsForValue().set("num", ++num);
            //2.4释放锁，del
            //先判断比较UUID值是否一样再释放锁
            String lockUuid = (String)redisTemplate.opsForValue().get("lock");
            if(lockUuid.equals(uuid)){
                redisTemplate.delete("lock");
            }


        }else{
            //3获取锁失败、每隔0.1秒再获取
            try {
                Thread.sleep(100);
                testLock();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    //与Redis的操作
    @GetMapping
    public String testRedis() {
        //设置值到redis
        redisTemplate.opsForValue().set("name","lucy");
        //从redis获取值
        String name = (String)redisTemplate.opsForValue().get("name");
        return name;
    }
}

六、分布式锁实现条件

为了确保分布式锁可用，至少要确保锁的实现同时满足以下四个条件：

  • 互斥性。在任意时刻，只有一个客户端能持有锁。
  • 不会发生死锁。即使有一个客户端在持有锁的期间崩溃而没有主动解锁，也能保证后续其他客户端能加锁。
  • 解铃还须系铃人。加锁和解锁必须是同一个客户端，客户端自己不能把别人加的锁给解了。
  • 加锁和解锁必须具有原子性。
几个苹果
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2022年Redis最新面试题- Redis分布式锁
q66562636的博客
05-12 6129
最近整理一份关于Redis常见面试题的，也会根据自己的经验， 标注一些出现的概率，最高5颗★出现的概率最高。比如这样: Redis 最适合的场景, 可以简单的说说吗? 出现概率: ★★★★ 整体目录大概如下: 目录 一、Redis基础知识 1、什么是 Redis, 有哪些优缺点? 2、Redis 最适合的场景, 可以简单的说说吗? 3、Redis 相比 Memcached 有哪些优势？ 4、一个字符串类型的值能存储最大容量是多少？ 5、Redis 读写分离 二、数据结构 1
redis-distribute-lock:Redis分布式锁的try-with-resources实现
05-17
今天我们重点说一下基于redis的分布式锁，redis分布式锁的实现我们可以参照。 实现Redis分布式锁的最简单的方法就是在Redis中创建一个key，这个key有一个失效时间（TTL)，以保证锁最终会被自动释放掉。当客户端释放...
Redis(九) - Redis之分布式锁
及时当勉励，岁月不待人
07-27 8184
Redis(九) - Redis之分布式锁
spring-data-redis redis 分布式锁
架构师的成长之路的博客
01-10 1448
public class RedisLockException extends Exception{ public RedisLockException(String message) { super(message); } public RedisLockException(String message, Throwable cause) { super(message, cause); } } public class Red.
Redis分布式锁--java实现
Artisan_w
01-13 1733
在单体redis中通过SETNX + EXPIRE方式可以为多个JVM加一个分布式锁，但是由于操作的非原子性会导致并发问题，因此出现了几种原子性解决方法，包括SETNX+时间value、lua脚本和SET扩展命令的方式解决，但是，依然会出现事务还没完成时间就失效，产生了新一轮并发，因此，通过添加一个看门狗线程定期检查能够解决这个问题，对于一个Java开发来说有一个Redisson框架实际上封装了lua脚本来实现。 哨兵和主从模式下的分布式redis，介绍了Redlock的原理与其缺陷。
redis应用篇----分布式锁
qq_40223554的博客
07-18 3万+
使用Synchronize和ReentrantLock等方法来实现线程间的同步只能锁住单实例内的临界区，但是现在大多数服务的部署方式都不是单实例的，你需要一种方法锁住其他实例的临界区那么今天的方法就可以帮助到你----分布式锁！！！
Redis(进阶)-----Redis实现分布式锁
weixin_43994761的博客
06-07 911
在多线程的环境下，为了保证一个代码块在同一时间只能由一个线程访问，Java中我们一般可以使用synchronized语法和ReetrantLock去保证，这实际上是本地锁的方式。但是现在公司都是流行分布式架构，在分布式环境下，如何保证不同节点的线程同步执行呢？实际上，对于分布式场景，我们可以使用分布式锁，它是控制分布式系统之间互斥访问共享资源的一种方式。
Go语言实现Redis分布式锁
m0_57408211的博客
04-04 1195
本文将基于go语言，使用了一个常用的go Redis客户端一步一步探索与实现一个简单的Redis分布式锁。SETNX 命令用于在Redis中设置某个不存在的键的值。如果该键不存在，则设置成功，如果该键存在，则设置失败，不作任何动作。基于此可以实现一种简单的抢占机制。先连接redis。新建lock.go文件。创建lock结构体，加锁和解锁方法。
微服务架构之：Redis的分布式锁---搭建生产可用的Redis分布式锁
qq_53999369的博客
08-18 2234
单体架构上，乐观锁和悲观锁可以锁住并发情况下的同步代码块，我们多使用synchronized来对方法加锁。但是在配上负载均衡的集群模式下，普通的synchronized是无法锁住从两台服务器同时进入的请求。JVM内部的锁监视器直接作废。所以锁的监视器一定要在JVM的外部，让所有JVM都去找独一无二的锁监视器来获取锁，这样也就只有一个线程获取锁，也就实现了多JVM的线程互斥。分布式锁核心是实现多进程之间的互斥，而满足这一点的方式有很多，常见的有三种：Mysql、Redis。
Redis分布式锁-这一篇全了解(Redission实现分布式锁完美方案)
热门推荐
Coder
09-03 11万+
前言 在某些场景中，多个进程必须以互斥的方式独占共享资源，这时用分布式锁是最直接有效的。 随着技术快速发展，数据规模增大，分布式系统越来越普及，一个应用往往会部署在多台机器上（多节点），在有些场景中，为了保证数据不重复，要求在同一时刻，同一任务只在一个节点上运行，即保证某一方法同一时刻只能被一个线程执行。在单机环境中，应用是在同一进程下的，只需要保证单进程多线程环境中的线程安全性，通过 JAVA 提供的 volatile、ReentrantLock、synchronized 以及 concurrent
redis-distributed-lock:Redis分布式锁
05-14
Redis分布式锁 该Java库实现了基于Redis的分布式锁管理器算法，网址为 要创建锁管理器： LockManager lockManager = new LockManager("127.0.0.1:6379, 127.0.0.1:6389, 127.0.0.1:6399"); 要获取锁： RLock ...
redis-distlock:使用Redis的分布式锁管理器
06-05
Redis::DistLock - 使用 Redis 的分布式锁管理器 概要 use Redis::DistLock; my $rd = Redis::DistLock->new( servers => [qw[ localhost:6379 ]] ); my $mutex = $rd->lock( "foo", 10 ); die( "failed to get a ...
redis-queue:基于Redis的分布式队列
05-15
添加Redis :: Queue类，该类可用作基于Redis的Distributed-Queue。 Redis通常用作消息传递服务器，以实现对后台作业或其他类型的消息传递任务的处理。 它实现了此处描述的可靠队列模式： ://redis.io/commands/...
人工智能-项目实践-redis-基于 Redis 实现的分布式锁.zip
12-23
人工智能-项目实践-redis-基于 Redis 实现的分布式锁 redis-lock 基于 Redis 实现的分布式锁。要求： Redis >= v7: 理论上来说低于 Redis 7 的也可以，但是暂时我还没在这些 Redis 版本上测试 Go >= 18: 低版本的 ...
跨服务器迁移 Redis 数据
jixiaoyu0209的博客
06-16 391
上述方法中，使用redis-cli工具进行数据导出和导入是较为简单和常用的方式，适合小规模数据迁移；而工具适合大规模数据迁移和实时同步。如果对停机时间要求不高，可以选择前两种方法；如果需要在线迁移，则推荐使用。
Redis简介
YJ_12340的博客
06-17 489
Redis（Remote Dictionary Server）是一个开源的高性能键值对存储系统，以其快速、灵活和可扩展性而著称。它是一个内存中的数据结构存储系统，支持多种数据类型，可以作为数据库、缓存、消息队列和发布/订阅系统使用。
Redis 内存碎片是什么？如何清理？
辣香牛肉面的博客
06-17 1298
你可以将内存碎片简单地理解为那些不可用的空闲内存。举个例子：操作系统为你分配了 32 字节的连续内存空间，而你存储数据实际只需要使用 24 字节内存空间，那这多余出来的 8 字节内存空间如果后续没办法再被分配存储其他数据的话，就可以被称为内存碎片。内存碎片Redis 内存碎片虽然不会影响 Redis 性能，但是会增加内存消耗。
RedisTemplate方法一览表
最新发布
赛赛
06-20 359
数据类型 RedisTemplate 方法 Redis命令 解释 应用场景 string opsForValue().set(key, value) SET 设置存储在指定 key 下的值 存储简单数据，如用户的设置、配置项 opsForValue().get(key) GET 获取存储在指定 key 下的值 读取存储的数据，如用户信息、配置参数 opsForValue().setIfAbsent(key, value) S
支付宝一面:如何基于redis实现分布式锁?
09-16
基于Redis实现分布式锁主要分为以下几个步骤： 1. 使用SETNX命令（set if not exists）尝试获取锁，如果返回1则表示获取锁成功，返回0则表示获取锁失败。 2. 设置锁的过期时间，防止获取锁后由于异常情况导致未...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值