Redisson分布式锁的静态方式和springboot管理方式两种实现

已于 2023-02-09 09:39:00 修改
阅读量226 收藏
点赞数
分类专栏： JAVA 文章标签： java 分布式锁
于 2023-02-09 09:37:59 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zero_zp/article/details/128947039
版权

Redisson分布式锁的实现

maven 引入依赖包

<dependency>
   <groupId>org.redisson</groupId>
   <artifactId>redisson</artifactId>
   <version>3.16.4</version>
</dependency>

静态方式 Redisson 分布式重入锁用法

Redisson 支持单点模式、主从模式、哨兵模式、集群模式，这里以单点模式为例：

import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;

import java.util.concurrent.TimeUnit;

public class RedisLock {

    public static void setLock(String lockKey,Long waitTimeout,Long leaseTime){
        // 1.构造redisson实现分布式锁必要的Config  redis 的连接地址和密码以及选择的数据库
        Config config = new Config();
        config.useSingleServer().setAddress("redis连接地址").setPassword("密码").setDatabase(第几个数据库);
        // 2.构造RedissonClient
        RedissonClient redissonClient = Redisson.create(config);
        // 3.获取锁对象实例（无法保证是按线程的顺序获取到）
        RLock rLock = redissonClient.getLock(lockKey);
        try {
            /**
             * 4.尝试获取锁
             * waitTimeout 尝试获取锁的最大等待时间，超过这个值，则认为获取锁失败
             * leaseTime   锁的持有时间,超过这个时间锁会自动失效（值应设置为大于业务处理的时间，确保在锁有效期内业务能处理完）
             */
            boolean res = rLock.tryLock((long)waitTimeout, (long)leaseTime, TimeUnit.SECONDS);
            System.out.println(res);
            if (res) {
                //成功获得锁，在这里处理业务
            }
        } catch (Exception e) {
            throw new RuntimeException("aquire lock fail");
        }finally{
            //无论如何, 最后都要解锁
            rLock.unlock();
        }
    }
}

springboot管理方式 Redisson 分布式重入锁用法

RedissonConfig 配置类
import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.ClusterServersConfig;
import org.redisson.config.Config;
import org.redisson.config.SentinelServersConfig;
import org.redisson.config.SingleServerConfig;
import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
import org.springframework.boot.context.properties.EnableConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.util.StringUtils;

import javax.annotation.Resource;

@Configuration
@EnableConfigurationProperties(RedissonProperties.class)
public class RedissonConfig {

    @Resource
    private RedissonProperties redissonProperties;

    @Bean
    @ConditionalOnMissingBean
    RedissonClient redissonSingle() {
        // 1.构造redisson实现分布式锁必要的Config  redis 的连接地址和密码以及选择的数据库
        Config config = new Config();

        //单机 redis地址
        String host = this.redissonProperties.getHost();
        //哨兵地址
        String[] sentinelAddr = this.redissonProperties.getSentinelAddresses();
        //其他节点地址
        String[] nodeAddresses = this.redissonProperties.getNodeAddresses();
        if (!StringUtils.isEmpty(host)) {
            config.setLockWatchdogTimeout((long)this.redissonProperties.getLockWatchdogTimeout());
            SingleServerConfig serverConfig = ((SingleServerConfig)config.useSingleServer().setAddress("redis://" + this.redissonProperties.getHost() + ":" + this.redissonProperties.getPort()).setTimeout((int)this.redissonProperties.getTimeout().getSeconds() * 1000)).setConnectionPoolSize(this.redissonProperties.getConnectionPoolSize()).setConnectionMinimumIdleSize(this.redissonProperties.getConnectionMinimumIdleSize().setDatabase(this.redissonProperties.getDatabase()));
            if (!StringUtils.isEmpty(this.redissonProperties.getPassword())) {
                serverConfig.setPassword(this.redissonProperties.getPassword());
            }
        } else if (sentinelAddr != null && sentinelAddr.length > 0) {
            config.setLockWatchdogTimeout((long)this.redissonProperties.getLockWatchdogTimeout());
            SentinelServersConfig serverConfig = (SentinelServersConfig)((SentinelServersConfig)((SentinelServersConfig)config.useSentinelServers().addSentinelAddress(this.redissonProperties.getSentinelAddresses()).setMasterName(this.redissonProperties.getMasterName()).setTimeout((int)this.redissonProperties.getTimeout().getSeconds() * 1000)).setMasterConnectionPoolSize(this.redissonProperties.getMasterConnectionPoolSize())).setSlaveConnectionPoolSize(this.redissonProperties.getSlaveConnectionPoolSize());
            if (!StringUtils.isEmpty(this.redissonProperties.getPassword())) {
                serverConfig.setPassword(this.redissonProperties.getPassword());
            }
        } else if (nodeAddresses != null && nodeAddresses.length > 0) {
            config.setLockWatchdogTimeout((long)this.redissonProperties.getLockWatchdogTimeout());
            ClusterServersConfig serverConfig = config.useClusterServers().addNodeAddress(this.redissonProperties.getNodeAddresses()).setScanInterval(this.redissonProperties.getScanInterval());
            if (!StringUtils.isEmpty(this.redissonProperties.getPassword())) {
                serverConfig.setPassword(this.redissonProperties.getPassword());
            }
        }

        // 2.根据config构造RedissonClient
        RedissonClient redissonClient = Redisson.create(config);

        return redissonClient;
    }
    @Bean
    @ConditionalOnClass(RedissonClient.class)
    RedisLock redisLock(){
        RedisLock redisLock = new RedisLock();
        return redisLock;
    }

}
RedissonProperties 属性类 （根据前缀去yml启动配置文件配置属性）
import lombok.Data;
import org.springframework.boot.context.properties.ConfigurationProperties;

import java.time.Duration;

@ConfigurationProperties(
        prefix = "spring.redis"
)
@Data
public class RedissonProperties {
    private Duration timeout;
    private String host;
    private int port = 6379;
    private String password;
    private int database = 0;
    private int connectionPoolSize = 64;
    private int connectionMinimumIdleSize = 10;
    private int slaveConnectionPoolSize = 250;
    private int masterConnectionPoolSize = 250;
    private int lockWatchdogTimeout = 30000;
    private String[] sentinelAddresses;
    private String masterName;
    private int scanInterval;
    private String[] nodeAddresses;
    private int maxPushCount = 6;
}
RedisLock （自己编写redission锁工具类）
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.redisson.api.RLock;
import org.springframework.stereotype.Component;

import java.util.concurrent.TimeUnit;
import java.util.function.Supplier;

@Component
public class RedisLock {

    @Autowired(
            required = false
    )
    private RedissonClient redissonClient;

    /**
     * @param lockKey
     * @param task 这里用的是Supplier，可以根据业务自己定制
     * @return
     */
    public  void tryLock(String lockKey, Supplier<?> task,int num){
        // 获取锁对象实例（无法保证是按线程的顺序获取到）
        RLock rLock = redissonClient.getLock(lockKey);
        try {

            boolean res = rLock.tryLock();
            //多次尝试获得
            while(--num>0 && !res){
                res = rLock.tryLock();
            }
            if (res) {
                //成功获得锁，在这里处理业务
                task.get();
            }else{
                throw new Exception("aquire lock fail");
            }
        } catch (Exception e) {
            //根据业务业务情况来确定是抛异常还是返回结果
            throw new RuntimeException(e);

        }finally{
            //当前线程还占领着锁，则释锁
            RLock lock = redissonClient.getLock(lockKey);
            if (lock != null && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
    }

    public  void tryLock(String lockKey, Supplier<?> task){
        tryLock(lockKey,task,1);
    }

    /**
     *
     * @param lockKey
     * @param task  这里用的是Supplier，可以根据业务自己定制
     * @param waitTimeout 尝试获取锁的最大等待时间，超过这个值，则认为获取锁失败
     * @param leaseTime 锁的持有时间,超过这个时间锁会自动失效（值应设置为大于业务处理的时间，确保在锁有效期内业务能处理完）
     * @param unit
     * @param num 总共尝试获得锁的次数
     * @return
     */
    public  T <T> tryLock(String lockKey, Supplier<T> task, Long waitTimeout, Long leaseTime,TimeUnit unit,int num){

        // 获取锁对象实例（无法保证是按线程的顺序获取到）
        RLock rLock = redissonClient.getLock(lockKey);
        try {
            /**
             * 尝试获取锁
             * waitTimeout 尝试获取锁的最大等待时间，超过这个值，则认为获取锁失败
             * leaseTime   锁的持有时间,超过这个时间锁会自动失效（值应设置为大于业务处理的时间，确保在锁有效期内业务能处理完）
             */
            boolean res = rLock.tryLock((long)waitTimeout, (long)leaseTime, unit);
            //多次尝试获得
            while(--num>0 && !res){
                res = rLock.tryLock((long)waitTimeout, (long)leaseTime, unit);
            }
            if (res) {
                long start = System.currentTimeMillis();
                log.info("aquire lock success [{}]",lockKey);
                //成功获得锁，在这里处理业务
                T result = task.get();
                log.info("execute task success [{}] and cost time {} ",lockKey,System.currentTimeMillis()-start);
                return result;
            }else{
                log.error("aquire lock fail [{}]",lockKey);
                throw new Exception("aquire lock fail");
            }
            //抛出业务本身抛出的异常(根据你实际项目定义)
        }catch (BusinessException e){
            log.error("execute task fail [{}]",lockKey);
            throw e;
        }
        catch (Exception e) {
            throw new RuntimeException(e);
        }
        finally{
            //当前线程还占领着锁，则释放锁
            RLock lock = redissonClient.getLock(lockKey);
            if (lock != null && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
            log.info("unlock [{}]",lockKey);
        }
    }


    public  T <T> tryLock(String lockKey, Supplier<T> task, Long waitTimeout, Long leaseTime,TimeUnit unit){
        return tryLock(lockKey,task,waitTimeout,leaseTime,unit,1);
    }

    /**
     * 批量加锁
     * @param lockKeyList 需要加锁的key
     * @param task 
     * @return
     * @param <T>
     */
    public <T> T multiTryLock(List<String> lockKeyList, Supplier<T> task) {
        return multiTryLock(lockKeyList, task, 5000L, 30000L, TimeUnit.MILLISECONDS, 1);
    }

    public <T> T multiTryLock(List<String> lockKeyList, Supplier<T> task, Long waitTimeout, Long leaseTime, TimeUnit unit) {
        return multiTryLock(lockKeyList, task, waitTimeout, leaseTime, unit, 1);
    }

    public <T> T multiTryLock(List<String> lockKeyList, Supplier<T> task, Long waitTimeout, Long leaseTime, TimeUnit unit, int num) {
        RedissonMultiLock multiLock = getMultiLock(lockKeyList);
        try {
            boolean res = multiLock.tryLock(waitTimeout, leaseTime, unit);

            while (--num > 0 && !res) {
                res = multiLock.tryLock(waitTimeout, leaseTime, unit);
            }

            if (res) {
                long start = System.currentTimeMillis();
                log.info("acquire multiLock success keyListSize:[{}]", lockKeyList.size());
                T result = task.get();
                log.info("execute multiLock success keyListSize:[{}] and cost time {} ", lockKeyList.size(), System.currentTimeMillis() - start);
                return result;
            } else {
                log.error("acquire multiLock fail keyListSize:[{}]", lockKeyList.size());
                throw new BusinessException(BlogisWmsResultStatusEnum.SYS_BUSY);
            }
        }  catch (BusinessException e) {
            log.error("execute task fail keyListSize:[{}] msg:[{}]", lockKeyList.size(),e.getMessage()==null?e.getCause():e.getMessage());
            throw e;
        } catch (Exception e) {
            log.error("execute task fail keyListSize:[{}] msg:[{}]", lockKeyList.size(),e.getMessage()==null?e.getCause():e.getMessage());
            throw new RuntimeException(e);
        } finally {
            unMultiLock(lockKeyList);
            log.info("unMultiLock [{}]", lockKeyList.size());
        }

    }

    /**
     * 获得连锁
     * @param lockKeyList
     * @return
     */
    private RedissonMultiLock getMultiLock(List<String> lockKeyList) {
        List<RLock> rLockList = new ArrayList<>(lockKeyList.size());
        for (String key : lockKeyList) {
            RLock rLock = redissonClient.getLock(key);
            rLockList.add(rLock);
        }
        RLock[] rLocks = rLockList.toArray(new RLock[0]);
        return  (RedissonMultiLock)redissonClient.getMultiLock(rLocks);
    }

    /**
     * 释放连锁
     * @param lockKeyList
     */
    private void unMultiLock(List<String> lockKeyList) {
        for (String key : lockKeyList) {
            RLock lock = redissonClient.getLock(key);
            if (lock != null && lock.isHeldByCurrentThread()) {
                lock.unlock();
            }
        }
        
    }

}

相关

也道长
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
使用redis实现分布式锁
earthhour的专栏
11-01 162
简介： 当高并发访问某个接口的时候，如果这个接口访问的数据库中的资源，并且你的数据库事务级别是可重复读（Repeatable read）的话，确实是没有线程问题的，因为数据库锁的级别就够了；但是如果这个接口需要访问一个静态变量、静态代码块、全局缓存的中的资源或者redis中的资源的时候，就会出现线程安全的问题。 案例： github地址： https://github.com/mzd123/my...
springboot整合redis ---- 缓存 分布锁 Redssion解决分布锁的bug(超时问题) redis常见面试题
BUG专业户
08-03 1714
spring boot整合redis redis的使用场景 1.缓存 2.分布锁(解决多线程并发问题) redission解决分布锁的超时问题 redis常见面试题
Redis分布式锁一文全攻略
weixin_44143114的博客
08-30 1836
分布式锁其实就是，控制分布式系统的不同进程共同访问共享资源的一种锁的实现。如果不同系统或同一个系统的不同主机去访问一个共享的临界资源，往往需要互斥来防止彼此干扰，以保证一致性。...
SpringBoot整合分布式锁redisson
JackMa的博客
02-20 1294
2、redisson配置类（如果redis没有密码就不需要private String password）3、创建redisson的bean。yml中redis的配置。1、导入maven坐标。
静态方法注入bean失败原因
qq_38071342的博客
07-24 1380
今天在写redission 的一个工具类的时候,随手写出下面的代码 package com.wt.redission.wtredission.utils; import org.redisson.api.*; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import javax.annotation.PostConstr
SpringBoot集成Redisson实现分布式锁的方法示例
08-25
SpringBoot集成Redisson是实现分布式锁的一种常用方法，下面将详细介绍其实现原理和示例代码。 首先，需要在pom.xml文件中添加Redisson依赖： ```xml <groupId>org.redisson <artifactId>redisson <version>...
SpringBoot使用Redisson实现分布式锁（秒杀系统）
08-25
主要为大家详细介绍了SpringBoot使用Redisson实现分布式锁，秒杀系统，文中示例代码介绍的非常详细，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Redisson分布式锁源码解析
08-27
Redisson分布式锁是一种基于Redis的分布式锁实现，继承了Reentrant Lock的特性，具有超时、重试、中断等功能，并且由于Redis的分布式特性，非常适合用来做Java中的分布式锁。本文将对Redisson分布式锁的源码进行解析...
Java使用Redisson分布式锁实现原理
08-26
Java 使用 Redisson 分布式锁实现原理是通过使用 Lua 脚本来实现分布式锁的加锁操作的，其核心是使用 evalWriteAsync() 方法来执行 Lua 脚本，并使用 KEYS 和 ARGV 两个参数来传递锁的名称和线程 ID。
案例实战-SpringBoot整合Redisson实现RedLock分布式锁同步
最新发布
06-26
本教程将基于SpringBoot框架，结合Redisson库来实现RedLock分布式锁，确保高可用性和数据一致性。 首先，让我们了解SpringBoot。SpringBoot是由Pivotal团队提供的全新框架，它简化了基于Spring的应用程序开发过程，...
Redis+Redisson 基础配置和使用
yiqiu1959的博客
08-04 5746
基于springBoot的redisson分布式锁 ，设置基础配置。
使用redisson提供分布式锁
qq_47155894的博客
11-20 2456
Redisson提供的分布式锁
redis分布式锁之redisson使用
weixin_39684440的博客
12-17 1412
public boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime) { RLock lock = redissonClient.getLock(lockKey); try { return lock.tryLock(waitTime, leaseTime, unit); } catch (InterruptedException
redission实现分布式锁
热门推荐
qq_45243783的博客
08-25 2万+
在开始提到Redis分布式锁之前，先说一下redis中的两个命令。 SETNX key value setnx 是SET if Not eXists(如果不存在，则 SET)的简写。
Redis分布式锁—Redisson+RLock可重入锁实现篇
niceyoo的博客
10-28 1万+
前言 平时的工作中，由于生产环境中的项目是需要部署在多台服务器中的，所以经常会面临解决分布式场景下数据一致性的问题，那么就需要引入分布式锁来解决这一问题。 针对分布式锁的实现，目前比较常用的就如下几种方案： 基于数据库实现分布式锁 基于 Redis 实现分布式锁 【本文】 基于 Zookeeper 实现分布式锁 接下来这个系列文章会跟大家一块探讨这三种方案，本篇为 Redis 实现分布式锁篇。 Redis分布式环境搭建推荐：基于Docker的Redis集群搭建 Redis分布式锁一览 说到 Red
Redisson分布式锁入门使用(可重入锁（lock）)
u011529483的博客
07-31 6431
Redisson 的可重入锁（lock）是阻塞其他线程的，需要等待其他线程释放锁。
（Redis使用系列） Springboot 整合Redisson 实现分布式锁 七
默默不代表沉默
05-14 6410
前言 该篇是基于springboot 项目整合 Redisson 实现对redis的操作。 内容： 1.使用RedissonClient对一些集合的常规操作，数据查询，存储等； 2.以AOP方式实现分布式锁 正文 第一步： pom.xml 添加核心依赖包： <dependency> <groupId>org.springframework.boot</groupId> <...
Redisson官方文档 - Redisson项目介绍
weixin_34242658的博客
03-19 1万+
Redisson项目介绍 Redisson是架设在Redis基础上的一个Java驻内存数据网格（In-Memory Data Grid）。充分的利用了Redis键值数据库提供的一系列优势，基于Java实用工具包中常用接口，为使用者提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工具包获得了协调分布式多机多线程并发系统的能力，...
springBoot集成redisson,以及redisson常用的方法
lizhenyi111的博客
12-27 5599
本文主要介绍redisson的分布式锁,其他功能请查看redisson的中文文档apihttps://github.com/redisson/redisson/wiki/%E7%9B%AE%E5%BD%95 首先导入redisson的依赖 <!--redisson--> <dependency> <groupI...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值