Redission源码详解

于 2024-08-16 18:19:02 发布
阅读量981 收藏 5
点赞数 6
文章标签： java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ludkjava/article/details/141231254
版权

环境搭建

redis搭建

在本地搭建个redis，启动redis服务端和客户端。客户端是为了观察redis中锁的信息。

依赖

新建个SpringBoot项目，依赖Redission jar包

<dependency>
	<groupId>org.redisson</groupId>
	<artifactId>redisson-spring-boot-starter</artifactId>
	<version>3.21.1</version>
</dependency>

工具类

@Service
public class RedisUtil {
    @Autowired
    private RedissonClient redissonClient;

    public  boolean tryLock(Long key){
        RLock rLock= redissonClient.getLock(String.valueOf(key));
        try {
            boolean lockResult=rLock.tryLock(10,30, TimeUnit.SECONDS);
            return lockResult;
        } catch (InterruptedException e) {
            e.printStackTrace();
            return false;
        }
    }
}

测试Controller

package com.ludk.weixin.controller;

import com.ludk.weixin.common.tool.RedisUtil;
import com.ludk.weixin.entity.Product;
import com.ludk.weixin.service.IProductService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.*;

import java.util.Collections;

@Controller
@Slf4j
@RequestMapping("/product")
public class ProductController {
    @Autowired
    RedisUtil redisUtil;




    @RequestMapping("/myProduct")
    @ResponseBody
    Object myProduct(@RequestParam("userId") Long userId){
        long before=System.currentTimeMillis();
        log.error("获取锁之前："+before);
        redisUtil.tryLock(userId);
        long after=System.currentTimeMillis();
        System.out.println("获取锁之后："+after);
        System.out.println((after-before)/1000);
        return productService.getMyProduct(userId);

}

源码思路分析

首先需要知道Redission实现的分布式锁有哪些特点？

  • 支持锁的超时，避免死锁。通过对Redis key设置超时时间实现。
  • 支持可重入锁，同一个线程可以多次获取锁。Redis中通过存储hash类型，其中一个字段记录次数实现。
  • 当线程A获取到锁执行业务逻辑且未执行完，如果锁超时，可以通过看门狗续锁的时间，避免其他线程获取锁。通过看门狗实现。

源码分析

初始化锁对象

主要是初始化默认锁的释放时间和uuid，下面会用到。

加锁方法

org.redisson.api.RLock#tryLock方法参数如下：

  • long waitTime：当获取锁失败时，等待waitTime时间后返回获取锁失败。
  • long leaseTime：锁释放时间，当获取到锁以后，这个锁多久失效。也就是redis中存储的锁的key的有效时间。
  • TimeUnit unit：上面两个时间的单位。
@Override
public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
	//将锁的等待时间转为毫秒数
    long time = unit.toMillis(waitTime);
    //当前时间，从现在起算锁的等待时间
    long current = System.currentTimeMillis();
    //当前线程id，因为是可重入锁，需要用threadId区别是否是当前线程。
    long threadId = Thread.currentThread().getId();
    //获取锁，如果ttl 为null则说明获取锁成功。否则ttl代表这个锁还有多久超时，超时则当前线程有获取到锁的可能
    Long ttl = tryAcquire(waitTime, leaseTime, unit, threadId);
    // lock acquired
    if (ttl == null) {
        return true;
    }
    // System.currentTimeMillis()是当前时间，current是进入tryLock这个方法的时间，time=time-(System.currentTimeMillis() - current)表示还有多少时间获取锁超时，time<=0就说明超时
    time -= System.currentTimeMillis() - current;
    if (time <= 0) {//获取锁超时，返回false。
        acquireFailed(waitTime, unit, threadId);
        return false;
    }
    //记录当前时间
    current = System.currentTimeMillis();
    //订阅监听redis消息，并且创建RedissonLockEntry，其中RedissonLockEntry中比较关键的是一个 Semaphore属性对象,用来控制本地的锁请求的信号量同步，返回的是netty框架的Future实现。
    CompletableFuture<RedissonLockEntry> subscribeFuture = subscribe(threadId);
    try {
    	//添加锁的监听，如果锁释放，会进入监听类，将Semaphore释放
    	// 阻塞等待subscribe的future的结果对象，如果subscribe方法调用超过了time，说明已经超过了客户端设置的最大wait time，则直接返回false，取消订阅，不再继续申请锁了。
        subscribeFuture.get(time, TimeUnit.MILLISECONDS);
    } catch (TimeoutException e) {
        if (!subscribeFuture.completeExceptionally(new RedisTimeoutException(
                "Unable to acquire subscription lock after " + time + "ms. " +
                        "Try to increase 'subscriptionsPerConnection' and/or 'subscriptionConnectionPoolSize' parameters."))) {
            subscribeFuture.whenComplete((res, ex) -> {
                if (ex == null) {
                    unsubscribe(res, threadId);
                }
            });
        }
        acquireFailed(waitTime, unit, threadId);
        return false;
    } catch (ExecutionException e) {
        acquireFailed(waitTime, unit, threadId);
        return false;
    }

    try {
    	//经过上面的计算，time是还多长时间获取锁超时，time已经被减掉一部分了。这里继续把消耗的时间减掉。
        time -= System.currentTimeMillis() - current;
        if (time <= 0) {//time<0，获取锁超时，返回false，获取锁失败。
            acquireFailed(waitTime, unit, threadId);
            return false;
        }
    
        while (true) {//死循环，有两个点可以调出循环。获取锁成功跳出、获取锁超时（失败）跳出
            long currentTime = System.currentTimeMillis();
            ttl = tryAcquire(waitTime, leaseTime, unit, threadId);
            // lock acquired
            if (ttl == null) {
                return true;
            }

            time -= System.currentTimeMillis() - currentTime;
            if (time <= 0) {
                acquireFailed(waitTime, unit, threadId);
                return false;
            }

            // waiting for message
            currentTime = System.currentTimeMillis();
            //下面的阻塞会在释放锁的时候，通过订阅发布及时获取锁
            if (ttl >= 0 && ttl < time) {//如果锁的超时时间小于等待时间，通过SemaphorerelaseryAcquire阻塞锁的释放时间
                commandExecutor.getNow(subscribeFuture).getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
            } else {//否则，通过Semaphore的tryAcquire阻塞传入的最大等待时间
                commandExecutor.getNow(subscribeFuture).getLatch().tryAcquire(time, TimeUnit.MILLISECONDS);
            }

            time -= System.currentTimeMillis() - currentTime;
            if (time <= 0) {
                acquireFailed(waitTime, unit, threadId);
                return false;
            }
        }
    } finally {//finally中取消订阅
        unsubscribe(commandExecutor.getNow(subscribeFuture), threadId);
    }
//        return get(tryLockAsync(waitTime, leaseTime, unit));
}

org.redisson.RedissonLock#tryAcquire方法

private Long tryAcquire(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
    return get(tryAcquireAsync0(waitTime, leaseTime, unit, threadId));
}

org.redisson.RedissonLock#tryAcquireAsync0方法

    private RFuture<Long> tryAcquireAsync0(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
        return getServiceManager().execute(() -> tryAcquireAsync(waitTime, leaseTime, unit, threadId));
    }

org.redisson.RedissonLock#tryAcquireAsync

private <T> RFuture<Long> tryAcquireAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId) {
    RFuture<Long> ttlRemainingFuture;
    if (leaseTime > 0) {//如果leaseTime >0，则传入锁释放时间，
        ttlRemainingFuture = tryLockInnerAsync(waitTime, leaseTime, unit, threadId, RedisCommands.EVAL_LONG);
    } else {//否则用默认的锁释放时间30000ms
        ttlRemainingFuture = tryLockInnerAsync(waitTime, internalLockLeaseTime,
                TimeUnit.MILLISECONDS, threadId, RedisCommands.EVAL_LONG);
    }
    CompletionStage<Long> s = handleNoSync(threadId, ttlRemainingFuture);
    ttlRemainingFuture = new CompletableFutureWrapper<>(s);

    CompletionStage<Long> f = ttlRemainingFuture.thenApply(ttlRemaining -> {
        // lock acquired
        if (ttlRemaining == null) {
            if (leaseTime > 0) {
                internalLockLeaseTime = unit.toMillis(leaseTime);
            } else {
            	//看门狗续时间，在锁要超时，业务还未执行完这种情况续锁时间。需要注意，leaseTime>0的时候不会有看门狗。
                scheduleExpirationRenewal(threadId);
            }
        }
        return ttlRemaining;
    });
    return new CompletableFutureWrapper<>(f);
}

org.redisson.RedissonLock#tryLockInnerAsync
该方法和redis交互，是锁实现的核心。

<T> RFuture<T> tryLockInnerAsync(long waitTime, long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
        return commandExecutor.syncedEval(getRawName(), LongCodec.INSTANCE, command,
                "if ((redis.call('exists', KEYS[1]) == 0) " +
                            "or (redis.call('hexists', KEYS[1], ARGV[2]) == 1)) then " +
                        "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                        "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                        "return nil; " +
                    "end; " +
                    "return redis.call('pttl', KEYS[1]);",
                Collections.singletonList(getRawName()), unit.toMillis(leaseTime), getLockName(threadId));
    }

分析这个lua脚本的参数：

  • KEYS[1]：是大key，判断是否有其他线程获取到锁。
  • ARGV[1]：锁的释放时间，这个锁如果不释放，多久会超时。
  • ARGV[2]：uuid+线程id，用于实现可重入锁。

分析lua脚本的逻辑：
if ((redis.call(‘exists’, KEYS[1]) == 0)or (redis.call(‘hexists’, KEYS[1] ,ARGV[2]) == 1))
then
redis.call(‘hincrby’, KEYS[1], ARGV[2], 1);
redis.call(‘pexpire’, KEYS[1], ARGV[1]);
return nil;
end;
return redis.call(‘pttl’, KEYS[1]);

  • redis.call(‘exists’, KEYS[1]) == 0：说明大key不存在，也就是没有其他线程获取锁，可以之间获取锁成功了。
  • redis.call(‘hexists’, KEYS[1] ,ARGV[2]) == 1)：redis这大key下，当前线程已经获取到了锁。
  • return redis.call(‘pttl’, KEYS[1])：如果不是上面两种情况，说明其他线程占用锁了，返回这个锁还有多长时间释放。

总结：如果没有其他线程获取锁，或者当前线程已经获取到锁，则锁加上超时时间、当前线程锁的次数加1、然后返回空；否则说明有其他线程已经获取到锁，返回这个锁还有多久超时。

其他

lock、tryLock方法区别，参考这个博客：https://blog.csdn.net/weixin_37684345/article/details/135815110

ludkjava
关注
  • 6
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redis第14讲——Redis实现分布式锁（Redission源码解析）
让~学习~成为一种习惯（橡 皮 人の技术博客）
04-25 1613
在多线程环境下，为了保证数据的线程安全，我们通常用加锁的方式，使同一时刻只有一个线程可以对这个共享资源进行操作，在单服务系统我们常用JVM锁——Synchronized、ReentrantLock等。然而在多台服务系统的情况下，JVM锁就无法在多个服务器之间生效了，这时候我们就需要用分布式锁来解决线程安全的问题。分布式锁的实现方式有很多，主流的就是基于数据库、zookeeper以及redis，当然使用redis的居多，由于篇幅原因，本节就详细介绍一下使用redis实现分布式锁的几种方式。
redissonSourceReading:redisson源码阅读
03-23
redissonSourceReading:redisson源码阅读
Redisson分布式锁源码浅析
最新发布
qq_39666711的博客
07-23 36
总结：在调用lock（）方法时，我们可以传入自定义的超时时间，也可以不传，如果不传那么将会使用Redisson默认的看门狗时间30s，需要注意的是，如果我们使用了自定义超时时间，那么Redisson不会自动为我们的锁续期，而不传时间Redisson会使用默认30s超时时间并且会自动为我们的锁进行续期。进入tryAcquire（）→ tryAcquireAsync（）方法，该方法首先会判断释放时间是否为-1，如果为-1则代表我们在前面没有传入超时时间，根据这个判断结果将会走两条不同的路。
redisson源码解析
weixin_53067547的博客
02-03 1056
由于synchronized跟ReetrantLock是JVM级别的锁，在分布式情况下失效，这时候我们通常会选择redisson基于redis封装好的分布式锁。下面我们一起来分析以下redisson的源码。
看懂Redisson分布式锁源码，其实并不难
02-24 1884
前言 上一篇文章写了Redis分布式锁的原理和缺陷，觉得有些不过瘾，只是简单的介绍了下Redisson这个框架，具体的原理什么的还没说过呢。趁年前项目忙的差不多了，反正闲着也是闲着，不如把Redisson的源码也学习一遍好了。 虽说是一时兴起，但仔细研究之后发现Redisson的源码解读工作量还是挺大的，其中用到了大量的Java并发类，并且引用了Netty作为通信工具，实现与Redis组件的远程调用，这些知识点如果要全部讲解的话不太现实，本文的重点主要是关于Redisson分布式锁的实现原理，所以网络通信和
Redisson源码解读-分布式锁
王谷雨的博客
11-07 907
Redisson是一个在Redis的基础上实现的Java驻内存数据网格（In-Memory Data Grid）。Redisson有一样功能是可重入的分布式锁。本文来讨论一下这个功能的特点以及源码分析。
Redis系列（二）Redisson分布式锁源码解析
CountryLord的博客
10-16 3149
Redisson分布式锁源码解析
redission 秒杀实现demo
05-28
Redisson 是一个基于 Redis 的 Java 客户端，它提供了丰富的企业级功能，包括分布式数据结构、锁、队列、映射等。在秒杀场景中，由于瞬时的高并发请求，传统的单机锁机制可能无法有效应对，此时 Redisson 的分布式锁...
java版的分布式锁示例源码(Redission).zip
01-15
**Redission的分布式锁** Redisson的分布式锁(`RLock`)实现了`java.util.concurrent.locks.Lock`接口，提供了与Java内置锁类似的功能，如`lock()`, `unlock()` 和 `tryLock()`. 它的优势在于锁的获取和释放都是跨...
Java注解如何基于Redission实现分布式锁
08-25
Java注解如何基于Redission实现分布式锁 Java注解是一种在Java语言中提供元数据的机制，可以用来标注Java代码中的元素，如类、方法、变量等。Redission是一个基于Redis的分布式锁实现库，本文将介绍如何使用Java...
springboot 集成Redission 简单完美解决分布式锁
06-03
在分布式系统中，锁是确保数据一致...通过学习这个Redission-demo，你可以掌握SpringBoot集成Redisson的基本流程，并理解如何利用它来解决分布式锁问题。不断探索和实践，你将在分布式系统的设计和实现上更加得心应手。
Redisson分布式锁源码解析
08-27
给大家分享了关于Redisson分布式锁源码相关的知识点内容，有兴趣的朋友们可以参考学习下。
redission的使用
09-18
redission的使用 博文：https://maoqizhi.blog.csdn.net/article/details/126923184 包括四个： 1、单机版redis存取 2、redis分布式锁 3、redis sentinel的存取 4、redis cluster的存取
Redisson分布式锁的源码分析
huchao_lingo的博客
04-02 1659
Redisson分布式锁的源码分析 Redisson 分布式锁实现思路 锁标识：Hash 数据结构，key 为锁的名字，filed 当前竞争锁成功线程的唯一标识，value 重入次数 队列：所有竞争锁失败的线程，会订阅当前锁的解锁事件，利用 Semaphore 实现线程的挂起和唤醒 源码分析 基于redisson3.11.5版本 加锁流程图 解锁核心源码：tryLockInnerAsync ...
十五、Redisson源码解析
小薛博客助力人人成为架构师
12-20 1866
十五、Redisson源码解析1、code2、缓存续命3、watchdog4、源码解析1、分析1 - 通过redisson新建出来的锁key，默认是30秒2、分析23、分析34、分析4 - watch dog自动延期机制5、分析56、流程解释7、加锁查看8、可重入锁查看9、解锁5、常见异常情况更多内容： 1、code public class WatchDogDemo { public static final String LOCKKEY = "AAA"; private static
Redisson 工作原理-源码分析
hayhead的博客
05-03 1076
时间不在于你拥有多少，而在于你怎样使用。 1：Redisson 是什么 个人理解：一种 可重入、持续阻塞、独占式的 分布式锁协调框架，可从 ReentrantLock 去看它。 ①：可重入 拿到锁的线程后续拿锁可跳过获取锁的步骤，只进行value+1的步骤。 ②：持续阻塞 获取不到锁的线程，会在一定时间内等待锁。 日常开发中，应该都用过redis 的setnx 进行分布式的操作吧，那setnx 返回了false我们第一时间是不是就结束了？ 因此redisson 优化了这个步骤，拿不到锁会进行等...
聊聊redisson的分布式锁
weixin_33757911的博客
09-21 150
序 本文主要研究一下redisson的分布式锁 maven <dependency> <groupId>org.redisson</groupId> <artifactId>redisson</artifactId>...
【分布式锁篇】Redisson源码分析
WangJava_的博客
07-26 521
Redisson，分布式锁，微服务，锁机制
Redis分布式锁-Redisson源码解析
Hello World
03-09 687
分布式锁 当我们在设计分布式锁的时候，我们应该考虑分布式锁至少要满足的一些条件，同时考虑如何高效的设计分布式锁 1、互斥 在分布式高并发的条件下，我们最需要保证，同一时刻只能有一个线程获得锁，这是最基本的一点。 2、防止死锁 在分布式高并发的条件下，比如有个线程获得锁的同时，还没有来得及去释放锁，就因为系统故障或者其它原因使它无法执行释放锁的命令,导致其它线程都无法获得锁，造成死锁。 所以分布式非常有必要设置锁的有效时间，确保系统出现故障后，在一定时间内能够主动去释放锁，避免造成死锁的情况。
redission锁源码解析
07-27
Redission 是一个基于 Redis 的 Java 分布式锁框架。它提供了一种简单且可靠的方式来实现分布式锁，以确保在分布式环境中的并发操作的一致性和互斥性。 Redission 的锁实现主要依赖于 Redis 的原子操作和 Lua 脚本。下面是 Redission 锁的源码解析： 1. 首先，Redission 提供了 `RLock` 接口作为分布式锁的主要接口。它提供了一系列的方法来获取锁、释放锁以及判断当前线程是否持有锁。 2. 在实现上，Redission 使用了 `RedissonLock` 类来具体实现 `RLock` 接口。该类内部维护了一个 `RMap` 对象，用于存储锁的状态信息。 3. 在获取锁时，Redission 会调用 `tryLockInner` 方法。该方法首先会尝试使用 Redis 的 `setnx` 命令来设置一个 Key-Value 对，其中 Key 是锁的名称，Value 是当前线程的标识符。如果设置成功，则表示当前线程获取到了锁；否则，表示锁已经被其他线程获取。 4. 在释放锁时，Redission 会调用 `unlockInner` 方法。该方法会使用 Redis 的 `eval` 命令执行一段 Lua 脚本来判断当前线程是否持有锁，并进行相应的解锁操作。 5. 为了确保锁的可重入性，Redission 使用了一个计数器来记录当前线程获取锁的次数。在每次获取锁时，计数器加一；在每次释放锁时，计数器减一。只有当计数器归零时，锁才会真正被释放。 总体来说，Redission 的锁实现是基于 Redis 的分布式原子操作和 Lua 脚本的。它通过对 Redis 的 Key-Value 存储进行操作，实现了简单且可靠的分布式锁机制。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值