Redisson（分布式锁、限流）

注意Redisson是基于Redis的，所以必须先引入Redis配置（参考SpringBoot集成Redis文章）

1. 集成Redisson

引入依赖

<!-- 二选一,区别是第一个自动配置，第二个还需要手动配置也就是第二步自定义配置，注意版本号！
但是我找不到合适的版本还是进行了自定义配置，也有可能不是我说的原因，记录TODO，后面处理-->
<!--引入redisson-->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson-spring-boot-starter</artifactId>
    <version>3.16.2</version>
</dependency>

<!-- 原生 -->
<dependency>
    <groupId>org.redisson</groupId>
    <artifactId>redisson</artifactId>
    <version>3.13.4</version>
</dependency>

自定义配置

package com.tjx.config;

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.codec.JsonJacksonCodec;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * <p>
 *
 * </p>
 *
 * @author tianjiaxin
 * @createTime 2024/6/4 15:31
 * @Description:
 */
@Configuration
public class RedissonConfig {

    @Value("${spring.redis.host:127.0.0.1}")
    private String redisHost;

    @Value("${spring.redis.password:123456}")
    private String password;

    @Value("${spring.redis.port:6379}")
    private String port;

    @Bean
    public RedissonClient getRedisson() {
        System.out.println("初始化redisson : " + redisHost);
        Config config = new Config();
        // 单机配置，集群配置用config.useClusterServers(),自行百度网上太多了！
        config.useSingleServer().setAddress("redis://" + redisHost + ":" + port).setPassword(password);
        config.setCodec(new JsonJacksonCodec());
        return Redisson.create();
    }
}

2. 分布式锁

参考文章：

分布式锁使用：https://blog.csdn.net/liuerpeng1904/article/details/135459765
加解锁分析：https://writer.blog.csdn.net/article/details/130613740

2.1. 如何使用？

redissonClient.getLock(“key”);	获取锁
rLock.tryLock(1, TimeUnit.MINUTES);	在1分钟内尝试加锁，并返回是否获取成功结果
rLock.lock();	加锁，如果不成功则一直阻塞
rLock.unlock();	释放锁
rLock.isHeldByCurrentThread()	判断当前线程是否持有锁（防止超时或网络原因造成自动释放锁，从而防止在手动释放锁的时候找不到锁而产生报错）

package com.tjx.service.impl;

import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.concurrent.TimeUnit;

/**
 * <p>
 *
 * </p>
 *
 * @author tianjiaxin
 * @createTime 2024/6/4 14:46
 * @Description:
 */
@Service
public class RedissonServiceImpl {
    @Autowired
    private RedissonClient redissonClient;

    public void test() {
//        new Thread(this::business_01).start();
//        new Thread(this::business_02).start();
//        new Thread(this::business_03).start();
        new Thread(this::business_04).start();
        new Thread(this::business_05).start();
    }

    public void business_01() {
        // 1.获取锁
        RLock rLock = redissonClient.getLock("business");
        System.out.println(getDate() + ": business_01 锁获取成功");
        try {
            // tryLock: 直接返回获取结果，1分钟内不断尝试获取锁，如果获取成功执行业务逻辑，否则释放锁
            boolean isLocked = rLock.tryLock(1, TimeUnit.MINUTES);
            System.out.println(getDate() + " : business_01 加锁成功");
            if (isLocked) {
                System.out.println(getDate() + ": business_01 开始执行业务逻辑");
                Thread.sleep(60000);
                System.out.println(getDate() + ": business_01 结束执行业务逻辑");
            }
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            System.out.println(getDate() + ": business_01 释放锁");
            // 判断当前线程是否持有锁（防止超时或网络原因造成自动释放锁，从而防止在手动释放锁的时候找不到锁而产生报错）
            if (rLock.isHeldByCurrentThread()) {
                rLock.unlock();
            }
        }
    }

    public void business_02() {
        // 1.获取锁
        RLock rLock = redissonClient.getLock("business");
        System.out.println(getDate() + ": business_02 锁获取成功");
        try {
            boolean isLocked = rLock.tryLock(1, TimeUnit.MINUTES);
            System.out.println(getDate() + " : business_02 加锁成功");
            if (isLocked) {
                System.out.println(getDate() + ": business_02 开始执行业务逻辑");
                Thread.sleep(60000);
                System.out.println(getDate() + ": business_02 结束执行业务逻辑");
            }
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            System.out.println(getDate() + ": business_02 释放锁");
            // 判断当前线程是否持有锁（防止超时或网络原因造成自动释放锁，从而防止在手动释放锁的时候找不到锁而产生报错）
            if (rLock.isHeldByCurrentThread()) {
                rLock.unlock();
            }
        }
    }

    public void business_03() {
        // 1.获取锁
        RLock rLock = redissonClient.getLock("business");
        System.out.println(getDate() + ": business_03 锁获取成功");
        try {
            boolean isLocked = rLock.tryLock(1, TimeUnit.MINUTES);
            System.out.println(getDate() + " : business_03 加锁成功");
            if (isLocked) {
                System.out.println(getDate() + ": business_03 开始执行业务逻辑");
                Thread.sleep(60000);
                System.out.println(getDate() + ": business_03 结束执行业务逻辑");
            }
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            System.out.println(getDate() + ": business_03 释放锁");
            // 判断当前线程是否持有锁（防止超时或网络原因造成自动释放锁，从而防止在手动释放锁的时候找不到锁而产生报错）
            if (rLock.isHeldByCurrentThread()) {
                rLock.unlock();
            }
        }
    }

    public void business_04() {
        // 1.获取锁
        RLock rLock = redissonClient.getLock("business");
        System.out.println(getDate() + ": business_04 锁获取成功");
        try {
            // 如果获取不到锁，则一直阻塞，直到获取到锁
            rLock.lock();
            System.out.println(getDate() + " : business_04 加锁成功");
            System.out.println(getDate() + ": business_04 开始执行业务逻辑");
            Thread.sleep(10000);
            System.out.println(getDate() + ": business_04 结束执行业务逻辑");
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            System.out.println(getDate() + ": business_04 释放锁");
            // 判断当前线程是否持有锁（防止超时或网络原因造成自动释放锁，从而防止在手动释放锁的时候找不到锁而产生报错）
            if (rLock.isHeldByCurrentThread()) {
                rLock.unlock();
            }
        }
    }

    public void business_05() {
        // 1.获取锁
        RLock rLock = redissonClient.getLock("business");
        System.out.println(getDate() + ": business_05 锁获取成功");
        try {
            rLock.lock();
            System.out.println(getDate() + " : business_05 加锁成功");
            System.out.println(getDate() + ": business_05 开始执行业务逻辑");
            Thread.sleep(10000);
            System.out.println(getDate() + ": business_05 结束执行业务逻辑");
        } catch (Exception e){
            e.printStackTrace();
        } finally {
            System.out.println(getDate() + ": business_05 释放锁");
            // 判断当前线程是否持有锁（防止超时或网络原因造成自动释放锁，从而防止在手动释放锁的时候找不到锁而产生报错）
            if (rLock.isHeldByCurrentThread()) {
                rLock.unlock();
            }
        }
    }

    public static String getDate() {
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String format = dateFormat.format(new Date());
        return format;
    }
}

OMS系统使用：

RLock rLock = redissonClient.getMultiLock(actualDeliveryDTO.getItems().stream()
    .map(OutboundOrderActualDeliveryByTruckloadItemDTO::getOrderNo)
    .distinct()
    .map(orderNo -> redissonClient.getLock(getLockKeyForOrderNo(orderNo)))
    .toArray(RLock[]::new));
try {
    rLock.lock();
    return doUpdateActualDeliveryByTruckload(actualDeliveryDTO);
} finally {
    rLock.unlock();
}

2.2. 加解锁分析

加锁：

尝试获取锁，通过lua加锁脚本获取
如果没有获取到锁，则订阅解锁消息，并阻塞
持有的线程释放锁之后，进行广播并唤醒阻塞的线程

两个问题

如果持有锁的线程崩了怎么办？
设置锁的时候有过期时间，超时自动释放
如果超过过期时间但是还没有执行完怎么办？
看门狗机制，监听持有锁的线程并定义增加过期时间

加锁lua脚本：

解锁：

很简单，直接执行解锁lua脚本

3. 限流

3.1. 基本使用

API详细解释文章：https://blog.csdn.net/qq_43686863/article/details/135634098

import lombok.extern.slf4j.Slf4j;
import org.redisson.api.RRateLimiter;
import org.redisson.api.RateIntervalUnit;
import org.redisson.api.RateType;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

/**
 * <p>
 *
 * </p>
 *
 * @author tianjiaxin
 * @createTime 2024/6/5 11:24
 * @Description:
 */
@Slf4j
@Service
public class RedissonRateLimiterServiceImpl {
    @Autowired
    private RedissonClient redissonClient;

    public void testRateLimiter(String phone) {
        // Step1.创建限流器
        RRateLimiter rateLimiter = redissonClient.getRateLimiter("PHONE:" + phone);
        // Step2.设置限流参数 每10s生成一个令牌
        // RateType.OVERALL 全局限流, RateType.PER_CLIENT 单机限流
        rateLimiter.trySetRate(RateType.OVERALL, 1, 10, RateIntervalUnit.SECONDS);
        // Step3.尝试获取1个令牌
        // 注意：acquire会阻塞等待, tryAcquire直接返回结果
        /*if (rateLimiter.tryAcquire()) {
            log.info("向手机：{}发送短信", phone);
        } else {
            log.info("被限流了！！！！！");
        }*/
        // 尝试获取1个令牌，获取到返回true，没有获取到就返回false
//        if (rateLimiter.tryAcquire(1)) {
//            log.info("向手机：{}发送短信", phone);
//        } else {
//            log.info("被限流了！！！！！");
//        }
        // 获取一个令牌，获取到返回true，没有获取到最多等待3秒
//        if (rateLimiter.tryAcquire(3, TimeUnit.SECONDS)) {
//            log.info("向手机：{}发送短信", phone);
//        } else {
//            log.info("被限流了！！！！！");
//        }

        // 获取1个令牌，获取到返回true，没有获取到最多等待3秒
        // 注意：permits参数的值必须小于等于trySetRate的rate
        if (rateLimiter.tryAcquire(1, 3, TimeUnit.SECONDS)) {
            log.info("向手机：{}发送短信", phone);
        } else {
            log.info("被限流了！！！！！");
        }

    }
}