自定义springboot组件--基于redisson实现分布式锁

置顶 已于 2022-06-22 14:47:03 修改
阅读量347 收藏 2
点赞数 2
分类专栏： 自定义springboot组件 文章标签： 分布式 spring boot java
于 2022-06-16 14:55:05 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Instanceztt/article/details/125315322
版权

一 引入

1.1 分布式锁的概念

在单进程（启动一个jvm）的系统中，当存在多个线程可以同时改变某个变量（可变共享变量）时，就需要对变量或代码块做同步，使其在修改这种变量时能够线性执行消除并发修改变量。而同步的本质是通过锁来实现的。为了实现多个线程在一个时刻同一个代码块只能有一个线程可执行，那么需要在某个地方做个标记，这个标记必须每个线程都能看到，当标记不存在时可以设置该标记，其余后续线程发现已经有标记了则等待拥有标记的线程结束同步代码块取消标记后再去尝试设置标记。这个标记可以理解为锁;
在这里插入图片描述
很多时候我们需要保证一个方法在同一时间内只能被同一个线程执行。在单机环境中，通过 Java 提供的并发 API 我们可以解决，但是在分布式环境下，就没有那么简单啦。

  • 分布式与单机情况下最大的不同在于其不是多线程而是多进程。
  • 多线程由于可以共享堆内存，因此可以简单的采取内存作为标记存储位置。而进程之间甚至可能都不在同一台物理机上，因此需要将标记存储在一个所有进程都能看到的地方。

在这里插入图片描述

如果是在集群或分布式环境中要保证多进程中的多线程的线程安全就要使用分布式锁，分布式锁的目的就是在分布式/集群环境中使用加锁手段保证多个服务节点对同一个数据进行顺序操作，保证数据的安全性
在这里插入图片描述
分布式锁:需要得有一把唯一且共享的锁，多个服务同时去获取锁，但是只有一个服务才能获取到锁，其他没有获取到锁的服务需要等待或者自旋，等获取到锁的服务业务执行完成释放锁，其他的服务就可以再次尝试获取锁。

1.2 基于redission实现分布式锁逻辑

Redisson是一个实现的Java操作Redis的工具包，它不仅提供了一系列常用的操作Redis的API，还提供了许多分布式服务。其中包括(BitSet, Set, Multimap, SortedSet, Map, List, Queue, BlockingQueue, Deque, BlockingDeque, Semaphore, Lock, AtomicLong, CountDownLatch, Publish / Subscribe, Bloom filter, Remote service, Spring cache, Executor service, Live Object service, Scheduler service) Redisson提供了使用Redis的最简单和最便捷的方法，Redisson的宗旨是促进使用者对Redis的关注分离，从而让使用者能够将精力更集中地放在处理业务逻辑上。

在这里插入图片描述

二 整体代码实现

核心思想:将整个分布式锁的底层实现逻辑抽离出来,通过aop实现分布锁,这种方式实现的分布式锁粒度比较粗会对整个方法进行加锁,如果要在要在更加细粒度的代码块中实现分布式锁可以直接代码中增加基于redission实现的分布式锁,抽离出来是为了更好的解耦.

定义分布式锁注解

@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.METHOD)
public @interface XlcpLock {
    /**
     * 所名称 支持spel表达式
     * @return
     */
    String name() default "";

    /**
     * 锁的类型 默认为可重入锁
     * @return
     */
    LockType lockType() default LockType.REENTRANT_LOCK;

    /**
     * 获取锁等待时间
     * @return
     */
    long waitTime() default Long.MIN_VALUE;

    /**
     * 锁超时时间
     * @return
     */
    long leaseTime() default Long.MIN_VALUE;

    /**
     * 获取锁失败处理策略
     */
    LockTimeOutStrategy lockTimeOutStrategy() default LockTimeOutStrategy.NO_OPERATION;

    /**
     * 自定义业务key
     * @return
     */
    String[] keys() default "";

    /**
     * 锁释放失败处理策略
     * @return
     */
    LockReleaseFailStrategy lockReleaseFailStrategy() default LockReleaseFailStrategy.NO_OPERATION;

}

定义prop系统自定义核心参数

@ConfigurationProperties(prefix = XlcpLockProperties.PRE_FIX)
@Data
public class XlcpLockProperties {

    public static final String PRE_FIX = "config.lock";
    /**
     * 获取锁超时时间
     */
    private Long waitTime = 60L;

    /**
     * 锁过期时间
     */
    private Long leaseTime = 60L;

    /**
     *  使用的redis数据库
     */
    private Integer dataBase = 1;

    /**
     *  编码器
     */
    private String codec = "org.redisson.codec.JsonJacksonCodec";
}

申明一个接口 用于申明锁的获取和释放

public interface Lock {

    /**
     * 获取锁
     * @param lockInfo
     * @return
     */
    Boolean acquire(LockInfo lockInfo);

    /**
     * 释放锁
     * @param lockInfo
     * @return
     */
    Boolean release(LockInfo lockInfo);

}

通过工厂模式+策略模式提供对外可访问的锁类型(这里只申明了一种可重入的锁)

public enum LockType {
    // 可重入锁
    REENTRANT_LOCK;
}

@Component
@RequiredArgsConstructor
public class ReentrantLock implements Lock, InitializingBean {

    private final RedissonClient redissonClient;

    private RLock rLock;

    @Override
    public Boolean acquire(LockInfo lockInfo) {
        rLock = redissonClient.getLock(lockInfo.getLockName());
        try {
            return rLock.tryLock(lockInfo.getWaitTime(),lockInfo.getLeaseTime(), TimeUnit.SECONDS);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return false;
    }

    @Override
    public Boolean release(LockInfo lockInfo) {
        if (rLock.isHeldByCurrentThread()){
            try {
                return rLock.forceUnlockAsync().get();
            } catch (InterruptedException e) {
                return false;
            } catch (ExecutionException e) {
                return false;
            }
        }
        return false;
    }

    @Override
    public void afterPropertiesSet() throws Exception {
        LockFactory.register(LockType.REENTRANT_LOCK,this);
    }
}
public class LockFactory {
    public static Map<LockType,Lock> LOCKS = new ConcurrentHashMap<LockType,Lock>();

    public static void register(LockType lockType,Lock lock){
        LOCKS.put(lockType,lock);
    }

    public static Lock getLock(LockType lockType){
        return LOCKS.get(lockType);
    }
}

申明获取锁失败处理策略

public interface LockTimeOutHandler {
    /**
     * 获取锁失败处理
     * @param lock
     * @param lockInfo
     */
    void handler(Lock lock, LockInfo lockInfo);
}
public enum LockTimeOutStrategy implements LockTimeOutHandler {

    /**
     * 不做任何处理
     */
    NO_OPERATION(){
        @Override
        public void handler(Lock lock, LockInfo lockInfo) {
            // do something
        }
    },

    /**
     * 快速失败
     */
    FAST_FAIL(){
        @Override
        public void handler(Lock lock, LockInfo lockInfo) {
            String message = String.format("获取锁失败,当前锁名称为:%s,获取锁的等待超时时间为:%ds", lockInfo.getLockName(), lockInfo.getWaitTime());
            throw new LockException(message);
        }
    },
    /**
     * 通过自旋一直去获取相应的锁资源
     */
    KEEP_ACQUIRE(){
        private static final long DEFAULT_INTERVAL = 100L;

        private static final long DEFAULT_MAX_INTERVAL = 3 * 60 * 1000L;
        @Override
        public void handler(Lock lock, LockInfo lockInfo) {
            long interval = DEFAULT_INTERVAL;
            // 内部自旋获取锁资源
            while (!lock.acquire(lockInfo)){
               if (interval>DEFAULT_MAX_INTERVAL){
                   String message = String.format("获取锁失败,当前锁名称为:%s,获取锁的等待超时时间为:%ds", lockInfo.getLockName(), lockInfo.getWaitTime());
                   throw new LockException(message);
               }
                try {
                    TimeUnit.MILLISECONDS.sleep(interval);
                    interval<<=1;
                } catch (InterruptedException e) {
                    e.printStackTrace();
                    throw new LockException("获取锁失败!");
                }
            }
        }
    };


}

申明释放锁失败的处理策略

public interface LockReleaseHandel {
    /**
     * 释放锁失败处理策略
     * @param lockInfo
     */
    void handler(LockInfo lockInfo);
}
public enum LockReleaseFailStrategy implements LockReleaseHandel {
    /**
     * 不做任何处理
     */
    NO_OPERATION(){
        @Override
        public void handler(LockInfo lockInfo) {

        }
    },

    /**
     * 快速失败
     */
    FAST_FAIL(){
        @Override
        public void handler(LockInfo lockInfo) {
            String errorMessge = String.format("当前锁释放失败,当前锁名称为:{}", lockInfo.getLockName());
            throw new LockException(errorMessge);
        }
    };
}

aop切面实现分布式锁

@Aspect
@RequiredArgsConstructor
@Slf4j
public class XlcpLockAspect {

    private final LockInfoProvider lockInfoProvider;


    @Around("@annotation(xlcpLock)")
    @SneakyThrows
    public Object around(ProceedingJoinPoint point, XlcpLock xlcpLock){
        // 构建分布式锁的基础信息
        LockInfo lockInfo = lockInfoProvider.getLockInfo(point, xlcpLock);

        Lock lock = LockFactory.getLock(xlcpLock.lockType());

        LockResource lockResource = new LockResource(lockInfo, lock);

        LockContextHolder.set(lockResource);

        try {
            Boolean acquire = lock.acquire(lockInfo);

            log.info("锁获取结果:{}",acquire);

            // 判断当前锁是否获取成功
            if (!acquire){
                // 获取锁的后置处理
                xlcpLock.lockTimeOutStrategy().handler(lock,lockInfo);
            }
            // 设置当前线程持有锁
            LockContextHolder.setRes();
        } catch (Exception exception) {
            exception.printStackTrace();
            LockContextHolder.remove();
        }
        return point.proceed();
    }

    /**
     * 方法执行完毕后释放锁资源
     * @param xlcpLock
     */
    @AfterReturning("@annotation(xlcpLock)")
    @SneakyThrows
    public void after(JoinPoint point,XlcpLock xlcpLock){
        releaseLock(xlcpLock);
        LockContextHolder.remove();
    }

    @AfterThrowing(value = "@annotation(xlcpLock)", throwing = "ex")
    public void afterThrowing (JoinPoint joinPoint, XlcpLock xlcpLock, Throwable ex) throws Throwable {
        releaseLock(xlcpLock);
        LockContextHolder.remove();
        throw ex;
    }

    private void releaseLock(XlcpLock xlcpLock) {
        LockResource lockResource = LockContextHolder.get();
        if (Objects.isNull(lockResource)){
            throw new LockException("上下文中不存在当前线程的锁资源");
        }
        if (lockResource.getRes()){
            Lock lock = lockResource.getLock();
            Boolean releaseResult = lock.release(lockResource.getLockInfo());
            lockResource.setRes(Boolean.FALSE);
            if (!releaseResult){
                // 释放锁后置处理
                xlcpLock.lockReleaseFailStrategy().handler(lockResource.getLockInfo());
            }
        }
    }

}

一些基础类

@UtilityClass
public class LockContextHolder {
    private final ThreadLocal<LockResource> THREAD_LOCAL_LOCK = new TransmittableThreadLocal<>();

    public LockResource get(){
        return THREAD_LOCAL_LOCK.get();
    }

    public void set(LockResource lockResource){
        THREAD_LOCAL_LOCK.set(lockResource);
    }

    public void remove(){
        THREAD_LOCAL_LOCK.remove();
    }

    public void setRes(){
        LockResource lockResource = get();
        lockResource.setRes(Boolean.TRUE);
        set(lockResource);
    }
}
@Data
public class LockInfo {
    /**
     * 锁名称
     */
    private String lockName;

    /**
     * 获取锁等待时间
     */
    private Long waitTime;

    /**
     * 锁超时时间
     */
    private Long leaseTime;

    private LockType lockType;

}
@Data
public class LockResource {
    private LockInfo lockInfo;
    private Lock lock;
    /**
     * 当前线程是否持有锁资源
     */
    private Boolean res = false;

    public LockResource(LockInfo lockInfo,Lock lock){
        this.lockInfo=lockInfo;
        this.lock=lock;
    }
}
@RequiredArgsConstructor
@Slf4j
public class LockInfoProvider {
    private final BusinessKeyProvider businessKeyProvider;

    private final LockNameProvider lockNameProvider;

    private final XlcpLockProperties xlcpLockProperties;

    public LockInfo getLockInfo(ProceedingJoinPoint point, XlcpLock xlcpLock){
        String businessName = businessKeyProvider.get(point, xlcpLock);
        String lockName = lockNameProvider.getLockName(businessName, point, xlcpLock);
        LockInfo lockInfo = new LockInfo();
        lockInfo.setLockName(lockName);
        lockInfo.setLockType(xlcpLock.lockType());
        lockInfo.setWaitTime(getWaitTime(xlcpLock));
        Long leaseTime = getLeaseTime(xlcpLock);
        lockInfo.setLeaseTime(leaseTime);
        // 如果不设置锁的过期时间 在极端情况下容易形成死锁
        if (leaseTime<0L){
            log.error("锁过期时间设置错误,当前过期时间为:{}",leaseTime);
            throw new LockException("锁过期时间设置错误");
        }

        return lockInfo;
    }

    private Long getWaitTime(XlcpLock xlcpLock){
        Long waitTime = xlcpLock.waitTime();
        return waitTime.equals(Long.MIN_VALUE)?xlcpLockProperties.getWaitTime():waitTime;
    }

    private Long getLeaseTime(XlcpLock xlcpLock){
        Long leaseTime = xlcpLock.leaseTime();
        return leaseTime.equals(Long.MIN_VALUE)?xlcpLockProperties.getLeaseTime():leaseTime;
    }

}
public class LockNameProvider {
    public static final String LOCK_NAME_PREFIX = "xlcplock";
    public String getLockName(String businessName, ProceedingJoinPoint point, XlcpLock xlcpLock){
        String name = getName(point, xlcpLock);
        String lockName = String.format("%s%s%s%s",LOCK_NAME_PREFIX, StrPool.COLON,name,businessName);
        return lockName;
    }

    /**
     * 获取当前定义的锁名称没有就为当前的权限定名
     * @param point
     * @param xlcpLock
     * @return
     */
    private String getName(ProceedingJoinPoint point, XlcpLock xlcpLock){
        String name = xlcpLock.name();
        if (StrUtil.isEmpty(name)){
            MethodSignature signature = (MethodSignature) point.getSignature();
            return String.format("%s%s",signature.getDeclaringTypeName(),signature.getMethod().getName());
        }
        return name;
    }
}
public class BusinessKeyProvider {

    private ParameterNameDiscoverer nameDiscoverer = new DefaultParameterNameDiscoverer();

    public String get(ProceedingJoinPoint point, XlcpLock xlcpLock){
        Method method = getMethod(point);
        // spel表达式解析
        List<String> spelDefinitionKeys = getSpelDefinitionKey(point, xlcpLock, method);
        return CollUtil.join(spelDefinitionKeys,"", StrPool.DASHED,"");
    }

    private Method getMethod(ProceedingJoinPoint point){
        MethodSignature methodSignature = (MethodSignature) point.getSignature();
        Method method = methodSignature.getMethod();
        if (method.getDeclaringClass().isAnnotation()){
            try {
                return point.getTarget().getClass().getDeclaredMethod(methodSignature.getName(),method.getParameterTypes());
            } catch (NoSuchMethodException noSuchMethodException) {
                noSuchMethodException.printStackTrace();
            }
        }
        return method;
    }

    private List<String> getSpelDefinitionKey(ProceedingJoinPoint point, XlcpLock xlcpLock,Method method){
        ArrayList<String> spelDefinitionKeyList = new ArrayList<>();
        SpelExpressionParser parser = new SpelExpressionParser();
        MethodBasedEvaluationContext context = new MethodBasedEvaluationContext(null, method, point.getArgs(), nameDiscoverer);
        Arrays.stream(xlcpLock.keys()).forEach(key->{
            if (StrUtil.isNotEmpty(key)){
                Expression expression = parser.parseExpression(key);
                spelDefinitionKeyList.add(ObjectUtils.nullSafeToString(expression.getValue(context)));
            }
        });
        return spelDefinitionKeyList;
    }
}

定义自动配置类

@Configuration
@EnableConfigurationProperties({XlcpLockProperties.class, RedisProperties.class})
@AutoConfigureAfter(RedisAutoConfiguration.class)
@ComponentScan("com.zkjc.xlcp.common.lock.lock")
public class XlcpLockAutoConfiguration {

    @Autowired
    private  XlcpLockProperties xlcpLockProperties;
    /**
     * 配置redisson客户端
     * @return
     */
    @SneakyThrows
    @Bean(destroyMethod = "shutdown")
    @ConditionalOnMissingBean
    public RedissonClient redissonClient(RedisProperties redisProperties,XlcpLockProperties xlcpLockProperties){
        RedisProperties.Cluster cluster = redisProperties.getCluster();
        Config config = new Config();
        if (Objects.nonNull(cluster)){
            // 集群模式
            List<String> nodes = cluster.getNodes();
            config.useClusterServers()
                    .addNodeAddress(ArrayUtil.toArray(nodes, String.class))
                    .setPassword(redisProperties.getPassword());
        }else {
            String host = StringUtil.endAt(redisProperties.getHost(), StrPool.COLON);
            String address = String.format("%s%s",host,redisProperties.getPort());
            config.useSingleServer()
                    .setAddress(address)
                    .setPassword(redisProperties.getPassword())
                    .setDatabase(xlcpLockProperties.getDataBase());
        }
        Codec codec=(Codec) ClassUtils.forName(xlcpLockProperties.getCodec(),ClassUtils.getDefaultClassLoader()).newInstance();
        config.setCodec(codec);
        config.setEventLoopGroup(new NioEventLoopGroup());
        return Redisson.create(config);
    }

    @Bean
    public BusinessKeyProvider businessKeyProvider(){
        return new BusinessKeyProvider();
    }

    @Bean
    public LockNameProvider lockNameProvider(){
        return new LockNameProvider();
    }

    @Bean
    public LockInfoProvider lockInfoProvider(){
        return new LockInfoProvider(businessKeyProvider(),lockNameProvider(),xlcpLockProperties);
    }

    @Bean
    public XlcpLockAspect xlcpLockAspect(){
        return new XlcpLockAspect(lockInfoProvider());
    }


}

在这里插入图片描述

三 客户端调用

在这里插入图片描述

Instanceztt
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
spring boot 利用redisson实现redis的分布式锁（二）
05-01
NULL 博文链接：https://liaoke0123.iteye.com/blog/2375556
springboot 集成Redission 简单完美解决分布式锁
06-03
springboot 集成Redission 简单完美解决分布式锁,上手看一眼就会
四、分布式锁之自定义分布式锁
weixin_45284646的博客
03-17 1071
本篇文章主要介绍了在分布式场景下对如何定制一个自己的分布式锁。主要内容有：分布式锁的基本原理、核心实现思路、具体的编码实现、常见的分布式锁问题（锁误删）及通过Lua脚本解决锁被误删问题等
基于Redisson使用自定义注解实现分布式锁
itigoitie的博客
08-01 422
基于Redisson使用自定义注解来实现分布式锁，获取不到锁时等待指定时间，并在期间不断尝试获取锁
springboot整合redisson（二）实现超强的分布式锁
2401_84003523的博客
04-18 293
面试题文档来啦，内容很多，485页！由于笔记的内容太多，没办法全部展示出来，下面只截取部分内容展示。面试题文档来啦，内容很多，485页！由于笔记的内容太多，没办法全部展示出来，下面只截取部分内容展示。
redisson分布式锁和自定义
2201_75364836的博客
07-16 141
redisson分布式锁
使用Redission自定义注解实现分布式锁（声明式）
qq_45502554的博客
06-26 589
1.主要依赖。
别再自己封装了，推荐一个功能强大的分布式锁框架：Lock4j
犬小哈
12-02 77
来源｜juejin.cn/post/7210653822850547770???? 欢迎加入小哈的星球，你将获得:专属的项目实战/ Java 学习路线 /一对一提问 / 学习打卡/ 赠书福利全栈前后端分离博客项目 1.0 版本完结啦，2.0 正在更新中...，全程手摸手，后端 + 前端全栈开发，从 0 到 1 讲解每个功能点开发步骤，1v1 答疑，直到项目上线。目前已更新了163小节，累计25w...
如何用 Redis 实现一个分布式锁
m0_67402236的博客
03-18 1832
场景模拟 一般电子商务网站都会遇到如团购、秒杀、特价之类的活动，而这样的活动有一个共同的特点就是访问量激增、上千甚至上万人抢购一个商品。然而，作为活动商品，库存肯定是很有限的，如何控制库存不让出现超买，以防止造成不必要的损失是众多电子商务网站程序员头疼的问题，这同时也是最基本的问题。 在秒杀系统设计中，超卖是一个经典、常见的问题，任何商品都会有数量上限，如何避免成功下订单买到商品的人数不超过商品数量的上限，这是每个抢购活动都要面临的难点。 针对大量的并发请求，我们可以通过 Redis 来抗，也就是说对于库存
自定义分布式锁注解
Mr. Ding的小博客
01-02 431
*** 尝试获取分布式锁* @param lockKey 锁* @param requestId 请求标识* @param expireSeconds 锁有效时间* @param overTime 超时时间* @param timeUnit 时间单位* @return 是否获取成功* @throws InterruptedException 中断异常*//*** 尝试获取分布式分段锁* @param segments 分段标识* @return 返回成功加锁的段*/
SpringBoot+AOP+Redission实战分布式锁
还是要稳扎稳打
08-03 1787
在集群环境下非单体应用存在的问题：JVM锁只能控制本地资源的访问，无法控制多个JVM间的资源访问，所以需要借助第三方中间件来控制整体的资源访问，redis是一个可以实现分布式锁，保证AP的中间件，可以采用setnx命令进行实现，但是在实现细节上也有很多需要注意的点，比如说获取锁、释放锁时机、锁续命问题，而redission工具能够有效降低实现分布式锁的复杂度，看门狗机制有效解决锁续命问题。
springboot集成redission（代码完整版）
m0_37825155的博客
10-11 6089
1.pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd
Redisson自定义序列化
yzh_1346983557的博客
01-10 6136
项目之前使用的RestTemplate api，RestTemplate的序列化使用的RedisSerializer接口，使用的实现类Jackson2JsonRedisSerializer。现在改为使用RedissonClient，RedissonClient的序列化使用的Codec接口，默认实现类JsonJacksonCodec。
案例实战-SpringBoot整合Redisson实现RedLock分布式锁同步
06-26
SpringBoot整合Redisson实现RedLock分布式锁同步源码包
SpringBoot集成Redisson实现分布式锁的方法示例
08-25
主要介绍了SpringBoot集成Redisson实现分布式锁的方法示例，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
SpringBoot使用Redisson实现分布式锁（秒杀系统）
08-25
主要为大家详细介绍了SpringBoot使用Redisson实现分布式锁，秒杀系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java开发案例-springboot-29-整合ShedLock实现分布式定时任务(redis版)-源代码+文档.rar
最新发布
05-31
Java开发案例-springboot-29-整合ShedLock实现分布式定时任务(redis版)-源代码+文档.rar Java开发案例-springboot-29-整合ShedLock实现分布式定时任务(redis版)-源代码+文档.rar Java开发案例-springboot-29-整合...
Java开发案例-springboot-28-整合Zipkin实现分布式链路追踪-源代码+文档.rar
05-31
Java开发案例-springboot-28-整合Zipkin实现分布式链路追踪-源代码+文档.rar Java开发案例-springboot-28-整合Zipkin实现分布式链路追踪-源代码+文档.rar Java开发案例-springboot-28-整合Zipkin实现分布式链路追踪-...
AOP+自定义注解+Redis实现分布式锁
小学生波波
10-29 2314
AOP+自定义注解+Redis实现分布式锁
基于redisson实现分布式锁
05-30
Redisson的分布式锁实现基于Redis的单点命令SETNX和GETSET命令，通过比较当前锁的值和请求持有锁的值，来判断是否可以获取锁。 下面是基于Redisson实现分布式锁的步骤： 1. 引入Redisson依赖 在Maven项目中，需要...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值