redis实现分布式锁

最新推荐文章于 2023-10-16 09:30:00 发布
最新推荐文章于 2023-10-16 09:30:00 发布
阅读量197 收藏
点赞数
分类专栏： redis 文章标签： redis 分布式 java lua 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41963899/article/details/108952106
版权

项目地址

https://gitee.com/quancong/redis

1、通过setnx、setex命令与springboot整合实现

    @Scheduled(cron = "0/10 * * * * *")
    public void lockJob() {
        String lock = LOCK_PREFIX + "LockNxExJob";
        boolean nxRet = false;
        try{

            //redistemplate setnx操作
            nxRet = redisTemplate.opsForValue().setIfAbsent(lock,getHostIp());
            Object lockValue = redisService.genValue(lock);

            //获取锁失败
            if(!nxRet){
                String value = (String)redisService.genValue(lock);
                //打印当前占用锁的服务器IP
                //logger.info("get lock fail,lock belong to:{}",value);
                return;
            }else{
                //redistemplate setex操作
                redisTemplate.opsForValue().set(lock,getHostIp(),3600);

                //获取锁成功
                //logger.info("start lock lockNxExJob success");
                Thread.sleep(5000);
            }
        }catch (Exception e){
            logger.error("lock error",e);

        }finally {
            if(nxRet){
                //logger.info("release lock success");
                redisService.remove(lock);
            }
        }
    }

问题：在执行redistemplate setnx操作和redistemplate setex操作之间如果分布式中某个服务应用宕机或者某台redis宕机，则这把锁永远也无法释放，造成死锁，如下图所示：

在这里插入图片描述

2、解决方案：通过setnx和setex命令连用实现

2.1、虽然redis原生命令形式支持setnx和setex连用，语法如下：

SET KEY VALUE [EX seconds] [PX milliseconds] [NX|XX]

  • EX seconds - 设置指定的到期时间，单位为秒。
  • PX milliseconds - 设置指定到期时间，单位为毫秒。
  • NX - 只有设置键，如果它不存在。
  • XX - 只有设置键，如果它已经存在。

例子：

127.0.0.1:6379> SET a redis EX 6 NX
OK
127.0.0.1:6379> ttl a
(integer) 3

但是2.0.5.RELEASE版本的springboot没有setex和setnx连用的api，但经过了一翻探索之后，使用RedisConnection，搞定。

    public boolean setLock(String key, long expire) {
        try {
            Boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.set(key.getBytes(), getHostIp().getBytes(), Expiration.seconds(expire) ,RedisStringCommands.SetOption.ifAbsent());
                }
            });
            return result;
        } catch (Exception e) {
            logger.error("set redis occured an exception", e);
        }
        return false;
    }
2.2、新版本springboot2.2.6.RELEASE支持setnx和setex连用并设置超时时间，大体思路和第1、种方式差不多，api如下：

在这里插入图片描述

@Test
    public void testIfAbsentAndExpiredTime(){
        Boolean a = redisTemplate.opsForValue().setIfAbsent("a", 1, 666, TimeUnit.SECONDS);
        System.out.println(a);
    }

3、Lua脚本实现

因lua脚本本身就是redis中的原子性操作，故是一种很有效的锁机制。

步骤：
3.1、在resource目录下面新增一个后缀名为.lua结尾的文件

在这里插入图片描述
3.2、编写lua脚本

local lockKey = KEYS[1]
local lockValue = KEYS[2]

-- setnx info
local result_1 = redis.call('SETNX', lockKey, lockValue)
if result_1 == true
then
local result_2= redis.call('SETEX', lockKey,3600, lockValue)
return result_1
else
return result_1
end

3.3、传入lua脚本的key和arg并执行脚本

@Service
public class LuaDistributeLock {

    private static final Logger logger = LoggerFactory.getLogger(LockNxExJob.class);

    @Autowired
    private RedisService redisService;
    @Autowired
    private RedisTemplate redisTemplate;

    private static String LOCK_PREFIX = "lua_";

    private DefaultRedisScript<Boolean> lockScript;


    @Scheduled(cron = "0/10 * * * * *")
    public void lockJob() {

        String lock = LOCK_PREFIX + "LockNxExJob";

        boolean luaRet = false;
        try {
            // 使用lua脚本
            luaRet = luaExpress(lock,getHostIp());

            //获取锁失败
            if (!luaRet) {
                String value = (String) redisService.genValue(lock);
                //打印当前占用锁的服务器IP
                //logger.info("lua get lock fail,lock belong to:{}", value);
                return;
            } else {
                //获取锁成功
                //logger.info("lua start  lock lockNxExJob success");
                Thread.sleep(5000);
            }
        } catch (Exception e) {
            logger.error("lock error", e);

        } finally {
            if (luaRet) {
                //logger.info("release lock success");
                redisService.remove(lock);
            }
        }
    }


    /**
     * 获取lua结果
     * @param key
     * @param value
     * @return
     */
    public Boolean luaExpress(String key,String value) {
        lockScript = new DefaultRedisScript<Boolean>();
        lockScript.setScriptSource(
                new ResourceScriptSource(new ClassPathResource("add.lua")));
        lockScript.setResultType(Boolean.class);
        // 封装参数
        List<Object> keyList = new ArrayList<Object>();
        keyList.add(key);
        keyList.add(value);
        // 调用redisTemplate.execute方法执行脚本
        Boolean result = (Boolean) redisTemplate.execute(lockScript, keyList);
        return result;
    }

    /**
     * 获取本机内网IP地址方法
     *
     * @return
     */
    private static String getHostIp() {
        try {
            Enumeration<NetworkInterface> allNetInterfaces = NetworkInterface.getNetworkInterfaces();
            while (allNetInterfaces.hasMoreElements()) {
                NetworkInterface netInterface = (NetworkInterface) allNetInterfaces.nextElement();
                Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
                while (addresses.hasMoreElements()) {
                    InetAddress ip = (InetAddress) addresses.nextElement();
                    if (ip != null
                            && ip instanceof Inet4Address
                            && !ip.isLoopbackAddress() //loopback地址即本机地址，IPv4的loopback范围是127.0.0.0 ~ 127.255.255.255
                            && ip.getHostAddress().indexOf(":") == -1) {
                        return ip.getHostAddress();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }
}

还存在问题：

B执行到一半Server A的任务才执行完，此时Server A会释放Server B所占有的锁，导致无锁。

在这里插入图片描述
解决方案：设置锁的时候redis存入当前服务器的ip，释放锁的时候判断当前线程的ip是否跟redis中的ip是否一致。

还存在问题

此时还可能出现一个问题，redis中存的是127.0.0.1，而并发执行的过程中导致另一个线程的ip（比如是127.0.0.2）和127.0.0.1比较了，导致不能释放锁。

解决方案：get到redis中ip的同时和当前线程ip比较一下是否相同，让两个命令同时执行，还是lua脚本。

@Component
public class JedisDistributedLock {

    private final Logger logger = LoggerFactory.getLogger(JedisDistributedLock.class);

    private static String LOCK_PREFIX = "JedisDistributedLock_";

    private DefaultRedisScript<Boolean> lockScript;

    @Resource
    private RedisTemplate<Object, Object> redisTemplate;

    @Autowired
    private RedisService redisService;

    public static final String UNLOCK_LUA;

    static {
        StringBuilder sb = new StringBuilder();
        sb.append("if redis.call(\"get\",KEYS[1]) == ARGV[1] ");
        sb.append("then ");
        sb.append("    return redis.call(\"del\",KEYS[1]) ");
        sb.append("else ");
        sb.append("    return 0 ");
        sb.append("end ");
        UNLOCK_LUA = sb.toString();
    }


    @Scheduled(cron = "0/10 * * * * *")
    public void lockJob() {

        String lock = LOCK_PREFIX + "JedisNxExJob";
        boolean lockRet = false;
        try {
            lockRet = this.setLock(lock, 600);

            //获取锁失败
            if (!lockRet) {
                String value = (String) redisService.genValue(lock);
                //打印当前占用锁的服务器IP
                logger.info("jedisLockJob get lock fail,lock belong to:{}", value);
                return;
            } else {
                //获取锁成功
                logger.info("jedisLockJob start  lock lockNxExJob success");
                Thread.sleep(5000);
            }
        } catch (Exception e) {
            logger.error("jedisLockJob lock error", e);

        } finally {
            if (lockRet) {
                logger.info("jedisLockJob release lock success");
                releaseLock(lock,getHostIp());
            }
        }
    }


    public boolean setLock(String key, long expire) {
        try {
            Boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
                @Override
                public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
                    return connection.set(key.getBytes(), getHostIp().getBytes(), Expiration.seconds(expire) ,RedisStringCommands.SetOption.ifAbsent());
                }
            });
            return result;
        } catch (Exception e) {
            logger.error("set redis occured an exception", e);
        }
        return false;
    }

    public String get(String key) {
        try {
            RedisCallback<String> callback = (connection) -> {
                JedisCommands commands = (JedisCommands) connection.getNativeConnection();
                return commands.get(key);
            };
            String result = redisTemplate.execute(callback);
            return result;
        } catch (Exception e) {
            logger.error("get redis occured an exception", e);
        }
        return "";
    }

    /**
     * 释放锁操作
     * @param key
     * @param value
     * @return
     */
    private boolean releaseLock(String key, String value) {
        lockScript = new DefaultRedisScript<Boolean>();
        lockScript.setScriptSource(
                new ResourceScriptSource(new ClassPathResource("unlock.lua")));
        lockScript.setResultType(Boolean.class);
        // 封装参数
        List<Object> keyList = new ArrayList<Object>();
        keyList.add(key);
        keyList.add(value);
        Boolean result = (Boolean) redisTemplate.execute(lockScript, keyList);
        return result;
    }

    /**
     * 获取本机内网IP地址方法
     *
     * @return
     */
    private static String getHostIp() {
        try {
            Enumeration<NetworkInterface> allNetInterfaces = NetworkInterface.getNetworkInterfaces();
            while (allNetInterfaces.hasMoreElements()) {
                NetworkInterface netInterface = (NetworkInterface) allNetInterfaces.nextElement();
                Enumeration<InetAddress> addresses = netInterface.getInetAddresses();
                while (addresses.hasMoreElements()) {
                    InetAddress ip = (InetAddress) addresses.nextElement();
                    if (ip != null
                            && ip instanceof Inet4Address
                            && !ip.isLoopbackAddress() //loopback地址即本机地址，IPv4的loopback范围是127.0.0.0 ~ 127.255.255.255
                            && ip.getHostAddress().indexOf(":") == -1) {
                        return ip.getHostAddress();
                    }
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

还存在问题：

任务执行时间很长，等redis分布式锁失效了，这个任务还在执行，此时是无锁状态，其它线程又会并发执行任务，又会造成线程安全问题。

解决方案：加一个看门狗。说白了，就是监听这把锁有没有失效，任务执行时间是否已经超过了锁的时间。可以加一个定时任务（看门狗），去redis中get一下这把锁，如果任务没执行完成就为这把锁加多一点超时时间，执行完成了这个定时器不做任何操作，任务代码里finally块给它删除了，相当于为这把锁续命。

还存在问题：

极端情况。redis主从复制的时候这把锁还没同步到从机，这个时候刚好有这把锁的主机崩了，那么redis中无锁。也就是说代码中刚上锁，redis主从复制时主机刚好崩了，其它线程又会继续执行任务，又会造成并发安全问题，解决方案暂时还没有。

还存在问题：

任务执行过程中还没等finally语句块执行删除锁的时候redis宕掉了，此时分布式锁是有过期时间的，如果这个过期时间很长，那么其他线程只能等这把锁过期了，那么这段时间其它线程也是阻塞的，也会造成服务不可用。

解决方案：使用Redisson。既然这把锁是redis的，redis宕掉直接影响这把锁能不能释放掉，而Redisson中的分布式锁保证了redis任务执行的原子性。如果任务没执行完，锁没被释放掉，那么一开始上的这把锁也不生效的。

tuonas
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java基于redis实现分布式锁代码实例
08-19
主要介绍了Java基于redis实现分布式锁代码实例,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
LocalLock 本地锁 实现拒绝重复提交
Save_the_baby的博客
02-08 958
本地锁的基本使用LocalLock 本地锁1实现原理2实现代码 LocalLock 本地锁 实现 拒绝一个请求在规定时间内多次调用 1实现原理 当一个请求被提交，把请求方法的参数存到redis并设置过期时间(比如5秒)，如果5秒内再次请求，redis中就可以查到信息，直接拒绝请求，否则正常通过 使用Spring AOP 对注解方法进行切面： ​ 从redis中 通过获取注解传入的参数 来查询数据 ​ 如果不存在，就执行方法，并将参数为key放入redis，并设置过期时间为规定不可重复时间 ​ 如果存在，就
springboot 搞定重复提交（本地锁）
xudong的博客
05-06 2731
在平时开发中，如果网速比较慢的情况下，用户提交表单后，发现服务器半天都没有响应，那么用户可能会以为是自己没有提交表单，就会再点击提交按钮重复提交表单，我们在开发中必须防止表单重复提交…. 重复提交 字面意思就是提交了很多次，比如同样的数据被插入到数据库多次。 方法 利用 自定义注解、Spring Aop、Guava Cache 实现表单防重复提交（不适用于分布式，后面会讲分布式方式…） 导入依赖 ...
判断页面是否有未提交的内容_防止表单重复提交看这里!!!
weixin_39641103的博客
11-30 246
要解决重复提交这事，先要知道什么是重复提交 假如用户的网速慢，用户点击提交按钮，却因为网速慢，而没有跳转到新的页面，这时的用户会再次点击提交按钮，举个例子：用户点击订单页面，当点击提交按钮的时候，也许因为网速的原因，没有跳转到新的页面，这时的用户会再次点击提交按钮，如果没有经过处理的话，这时用户就会生成两份订单，类似于这种场景都叫重复提交。 好了，为了解决这个问题，...
Redis 分布式锁
长期更新Java自学笔记
07-01 1329
随着业务发展的需要，原单机部署的系统被演化成分布式集群系统后，由于分布式系统多线程、多进程并且分布在不同机器上，这将使原单机部署情况下的并发控制锁策略失效，单纯的 Java API 并不能提供分布式锁的能力。为了解决这个问题就需要一种跨 JVM 的互斥机制来控制共享资源的访问，这就是分布式锁要解决的问题！说得通俗些，集群中上了锁后，无论当前操作在哪台机器，所有的机器都会识别并且等待，锁释放后其他操作才能进行，这就是分布式锁，对所有集群里都有效分布式锁主流的实现方案：每一种分布式锁解决方案都有各自的优缺点，其
Redis实现分布式锁（SETNX）
mlwsmqq的博客
01-09 8831
本文详细介绍了什么是分布式锁、分布式锁的特征、应用场景；一步一步的手动实现分布式锁，分析其中需要特别注意的地方，带着大家理清其中的思路；相信对大家会有所帮助
Spring Boot (32) Lock 本地锁
weixin_30808575的博客
06-15 639
平时开发中，有时会双击提交表单造成重复提交，或者网速比较慢时还没有响应又点击了按钮，我们在开发中必须防止重复提交 一般在前台进行处理，定义个变量，发送请求前判断变量值为true，然后把变量设置为false，可以防止重复提交问题。如果前台没有做这个控制那就需要后端来处理 Lock 注解 　　创建一个LocalLock注解，简单一个key就行了，由于暂时还未用到redis所以expire是摆设 ...
Redis实现分布式锁(附源码+讲义)
07-01
分布式锁有很多种解决方案，今天我们要讲的是怎么使用缓存数据库Redis来实现分布式锁。 课程目标:  理解redis分布式锁的应用场景  掌握redis分布式锁的实现原理  掌握redis分布式锁在微服务项目中的应用  掌握...
redis实现分布式锁,自旋式加锁,lua原子性解锁
07-16
redis实现分布式锁,自旋式加锁,lua原子性解锁
redis分布式锁
12-16
redis工具类，可用于操作redis增删改查，实现了分布式锁
详解使用Redis SETNX 命令实现分布式锁
12-16
使用Redis的 SETNX 命令可以实现分布式锁，下文介绍其实现方法。 SETNX命令简介 命令格式 SETNX key value 将 key 的值设为 value，当且仅当 key 不存在。 若给定的 key 已经存在，则 SETNX 不做任何动作。 SETNX 是SET if Not eXists的简写。 返回值 返回整数，具体为 – 1，当 key 的值被设置 – 0，当 key 的值没被设置 例子 redis> SETNX mykey “hello” (integer) 1 redis> SETNX mykey “hello” (integer) 0 redis
基于redis实现分布式锁的原理与方法
12-14
redis实现分布式锁 数据库实现分布式锁 zk实现分布式锁 今天我们介绍通过redis实现分布式锁。实际上这三种和java对比看属于一类。都是属于程序外部锁。 原理剖析 上述三种分布式锁都是通过各自为依据对各个请求...
使用 Redis 的 SETNX 命令实现分布式锁
weixin_45106532的博客
04-28 431
使用 Redis 实现分布式锁，具体实现思想是使用 Redis 的 SETNX 命令尝试获取锁，如果 SETNX 返回 1，则表示成功获取锁；如果 SETNX 返回 0，则表示锁已经存在，需要判断锁是否已经过期，如果锁已经过期，则使用 GETSET 命令尝试获取锁。如果 GETSET 返回的值等于之前获取的值，则表示成功获取锁；如果 GETSET 返回的值不等于之前获取的值，则表示锁已经被其他进程获取。释放锁时，使用 DEL 命令删除锁的键。
Redis实现分布式锁：setnx
m0_45806184的博客
08-11 2253
Redis实现分布式锁：setnx
面试系列 - Redis分布式锁3种实现方式对比分析
最新发布
境里婆娑
10-16 149
在分布式系统中，实现分布式锁是一个常见的问题，Redis 是一个常用的工具，用于实现分布式锁。
基于Redis的Setnx实现分布式锁
qq_44299529的博客
06-09 3245
基于Redis的Setnx实现分布式锁

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值