redission分布式锁测试代码

文章参考：
https://juejin.cn/post/7026291454532124680

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/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.6.2</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>cn.shutdown</groupId>
    <artifactId>redission</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>redission</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!-- 配置使用 redis 启动器 -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.redisson</groupId>
            <artifactId>redisson-spring-boot-starter</artifactId>
            <version>3.13.6</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

application.yml

server:
  port: 9090
  address: 127.0.0.1

#spring:
#  # Redis配置
#  redis:
#    timeout: 6000 # 连接超时时长（毫秒）
##    password:
#    database: 0
#    host: 127.0.0.1
#    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
spring:
  redis:
    database: 0
    host: 127.0.0.1
    jedis:
      pool:
        max-active: 8
        max-idle: 8
        max-wait: -1
        min-idle: 0
    password: 123456
    port: 6399
    timeout: 300

package cn.shutdown.redission;

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;
    }
}

package cn.shutdown.redission;

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);
    }
}

package cn.shutdown.redission;

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.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;

    @RequestMapping("/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());
    }

    @RequestMapping("/testLock12")
    public ApiResult 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);
    }

}