[大数据]redisson分布式锁使用小记

首先关于redisson的介绍，这里就不搬运了，贴一下github原地址文档：

由于我这里只是简单使用了redisson的 分布式锁 的功能，这里仅记录下锁的简单使用。

如果仅仅用Redisson的锁，可以直接查看官方文档 8.分布式锁和同步器

此次所用锁为可重入锁

8.1. 可重入锁（Reentrant Lock）

基于Redis的Redisson分布式可重入锁RLock Java对象实现了java.util.concurrent.locks.Lock接口。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。

RLock lock = redisson.getLock("anyLock");
// 最常见的使用方法
lock.lock();

大家都知道，如果负责储存这个分布式锁的Redisson节点宕机以后，而且这个锁正好处于锁住的状态时，这个锁会出现锁死的状态。为了避免这种情况的发生，Redisson内部提供了一个监控锁的看门狗，它的作用是在Redisson实例被关闭前，不断的延长锁的有效期。默认情况下，看门狗的检查锁的超时时间是30秒钟，也可以通过修改Config.lockWatchdogTimeout来另行指定。
另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。

另外Redisson还通过加锁的方法提供了leaseTime的参数来指定加锁的时间。超过这个时间后锁便自动解开了。

// 加锁以后10秒钟自动解锁
// 无需调用unlock方法手动解锁
lock.lock(10, TimeUnit.SECONDS);

// 尝试加锁，最多等待100秒，上锁以后10秒自动解锁
boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);
if (res) {
   try {
     ...
   } finally {
       lock.unlock();
   }
}

Redisson同时还为分布式锁提供了异步执行的相关方法：

RLock lock = redisson.getLock("anyLock");
lock.lockAsync();
lock.lockAsync(10, TimeUnit.SECONDS);
Future<Boolean> res = lock.tryLockAsync(100, 10, TimeUnit.SECONDS);

RLock对象完全符合Java的Lock规范。也就是说只有拥有锁的进程才能解锁，其他进程解锁则会抛出IllegalMonitorStateException错误。但是如果遇到需要其他进程也能解锁的情况，请使用分布式信号量Semaphore 对象.

首先springboot整合redisson需要引入redisson的依赖：

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

亲测以上版本，配合springboot：2.2.5.RELEASE版本，正常使用。

单机版redis的配置文件跟原来springboot集成redis一样。

spring:
    # Redis配置
    redis:
      timeout: 6000 # 连接超时时长（毫秒）
      password: huauN@2021
      database: 0
      host: 192.168.104.64
      port: 6379
      #cluster:
        #max-redirects: 3  # 获取失败 最大重定向次数
        #nodes:
          #- 192.168.104.101:6379
      lettuce:
        pool:
          max-active: 1024 # 连接池最大连接数（默认为8，-1表示无限制 如果pool已经分配了超过max_active个jedis实例，则此时pool为耗尽）
          max-wait: 10000 #最大等待连接时间，单位毫秒 默认为-1，表示永不超时，超时会抛出JedisConnectionException
          max-idle: 10
          min-idle: 5

Redis配置映射类 RedisConfigProperties.java

import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;
import java.util.List;

/**
 * Redis配置映射类
 *
 * @author linmengmeng
 * @date 2021-03-11
 **/

@Component
@ConfigurationProperties(prefix = "spring.redis")
public class RedisConfigProperties {
    private Integer timeout;
    private Integer database;
    private Integer port;
    private String host;
    private String password;
    private cluster cluster;

    public static class cluster {
        private List<String> nodes;

        public List<String> getNodes() {
            return nodes;
        }

        public void setNodes(List<String> nodes) {
            this.nodes = nodes;
        }
    }

    public Integer getTimeout() {
        return timeout;
    }

    public void setTimeout(Integer timeout) {
        this.timeout = timeout;
    }

    public Integer getDatabase() {
        return database;
    }

    public void setDatabase(Integer database) {
        this.database = database;
    }

    public Integer getPort() {
        return port;
    }

    public void setPort(Integer port) {
        this.port = port;
    }

    public String getHost() {
        return host;
    }

    public void setHost(String host) {
        this.host = host;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public RedisConfigProperties.cluster getCluster() {
        return cluster;
    }

    public void setCluster(RedisConfigProperties.cluster cluster) {
        this.cluster = cluster;
    }
}

添加自动装配类：RedissonConfig.java

import gc.cnnvd.config.properties.RedisConfigProperties;
import org.redisson.Redisson;
import org.redisson.config.Config;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

/**
 * @author linmengmeng
 * @author 2021-08-30
 */
@Configuration
public class RedissonConfig {

    @Autowired
    private RedisConfigProperties redisConfigProperties;

    /**
     * redis://host:port
     */
    private static final String REDIS_ADDRESS = "redis://%s:%s";

//    /**
//     * 集群模式-添加redisson的bean
//     * @return
//     */
//    @Bean
//    public Redisson redisson() {
//        //redisson版本是3.5，集群的ip前面要加上“redis://”，不然会报错，3.2版本可不加
//        List<String> clusterNodes = new ArrayList<>();
//        for (int i = 0; i < redisConfigProperties.getCluster().getNodes().size(); i++) {
//            clusterNodes.add("redis://" + redisConfigProperties.getCluster().getNodes().get(i));
//        }
//        Config config = new Config();
//        ClusterServersConfig clusterServersConfig = config.useClusterServers()
//                .addNodeAddress(clusterNodes.toArray(new String[clusterNodes.size()]));
//        clusterServersConfig.setPassword(redisConfigProperties.getPassword());//设置密码
//        return (Redisson) Redisson.create(config);
//    }

    /**
     * Redisson单机模式
     * @return
     */
    @Bean
    public Redisson RedissonConfig(){
        Config config = new Config();
//        config.useSingleServer().setAddress("redis://localhost:6379").setDatabase(redisConfigProperties.getDatabase());
        config.useSingleServer().setAddress(String.format(REDIS_ADDRESS, redisConfigProperties.getHost(), redisConfigProperties.getPort()))
                .setDatabase(redisConfigProperties.getDatabase())
                .setPassword(redisConfigProperties.getPassword());// 没有密码可以不设置
        return (Redisson) Redisson.create(config);
    }
}

创建测试接口测试分布式锁：

import gc.cnnvd.framework.common.api.ApiResult;
import lombok.extern.slf4j.Slf4j;
import org.redisson.Redisson;
import org.redisson.api.RLock;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;

/**
 * @Auther linmengmeng
 * @Date 2021-09-01 15:37
 */
@Slf4j
@RestController
@RequestMapping("/tourist")
public class TestRedissonLockController {

    private static String FORMAT_LOCKKEY = "testLockKey:%s";//分布式锁的key

    @Autowired
    private RedisTemplate redisTemplate;

    @Autowired
    private Redisson redisson;

    @PostMapping("/testLock11")
    public ApiResult<Boolean> testLock11() {
        String lockKey = String.format(FORMAT_LOCKKEY, 3);
        log.info("-------lockKey:{}", lockKey);
        RLock lock = redisson.getLock(lockKey);
        log.info("-------创建锁之后 isLocked-1:{}", lock.isLocked());
//        try {
//            Thread.sleep(10000);
//        } catch (InterruptedException e) {
//            e.printStackTrace();
//        }
        Future<Boolean> res = lock.tryLockAsync(10, 30, TimeUnit.SECONDS);
        log.info("-------tryLockAsync 后 isLocked-2:{}", lock.isLocked());
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        if (lock.isLocked()){
            log.info("-------10秒 后----isLocked-3:{}", lock.isLocked());
            //throw new BusinessException("测试获取锁后发生异常");
        }
        if (lock.isHeldByCurrentThread()){
            log.info("-------isHeldByCurrentThread:{}", lock.isHeldByCurrentThread());
        }
        boolean result = false;
        try {
            result = res.get();
            log.info("-------result:" + result);
            if (result){
                Thread.sleep(10000);
                if (lock.isHeldByCurrentThread()){
                    log.info("-------isHeldByCurrentThread:{}", lock.isHeldByCurrentThread());
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            e.printStackTrace();
        }finally {
            log.info("-------666666-------unlock-isLocked:{}", lock.isLocked());
            if (lock.isLocked()){
                log.info("-------88888888-------解锁解锁:{}", lock.isLocked());
                lock.unlock();
            }
        }
        log.info("res.get:{}", result);
        return ApiResult.ok(lock.isLocked());
    }

    @PostMapping("/testLock12")
    public ApiResult<Boolean> testLock12() {
        String lockKey = String.format(FORMAT_LOCKKEY, 3);
        log.info("====================lockKey:{}", lockKey);
        RLock lock = redisson.getLock(lockKey);
        log.info("====================isLocked-1:{}", lock.isLocked());
        Future<Boolean> res = lock.tryLockAsync(5, 2, TimeUnit.SECONDS);
        boolean locked = lock.isLocked();
        log.info("====================isLocked-2:{}", locked);
        if (locked){
            if (lock.isHeldByCurrentThread()){
                log.info("====================锁住了，是我的锁");
            }else {
                log.info("====================锁住了，不是我的锁");
            }
        }
        Boolean getLock = null;
        log.info("====================getLock-2:{}", getLock);
        return ApiResult.ok(locked);
    }

}

在 testLock11 接口里面添加线程睡眠，模仿程序运行占用锁，这时可以在redis里面看到我们加锁的key：

刚开始一直没有找到key，后来才发现，线程运行完成后，自动释放了锁，刚开始想着不手动释放锁，实现另外的线程获取锁会怎样呢，结果在redis里就是找不到这
个锁的标识的key的值。，后面把睡眠时间拉长，才找到redis里面的key。

后面在用到代码里面，对加锁和锁的判断使用如下：

• 设置加锁的唯一标识
• 获取锁，并持有，做自己的业务逻辑

// 尝试获取锁-异步，第一个时间表示:最多等待时间，第二个时间参数表示:上锁以后多久自动解锁
Future<Boolean> res = lock.tryLockAsync(5, 5, TimeUnit.SECONDS);
if (lock.isLocked() && lock.isHeldByCurrentThread()){
    // 处理业务逻辑
    // 解锁
    if (lock.isLocked()){
        lock.unlock();
    }
    if (!lock.isLocked()){
        log.info("解锁成功");
    }
    return;
}

这里判断加锁我使用了：lock.isLocked() && lock.isHeldByCurrentThread()，这样可以确保只有一个线程进入锁的部分。

释放锁的时候，又加了一个判断：lock.isLocked()，避免由于业务逻辑耗时超过锁的自动释放时间，在执行lock.unlock();时，如果锁已经释放，或者别的线程拿到锁了，当前线程释放锁会抛出异常，最后在业务执行完毕，可以手动释放锁。如果对锁的时效性要求不高，也可不做处理，让锁到期自动释放。