Springboot（十三）分布式锁redisson

逃离我推掉我的手 2022-05-21 07:20 239阅读 0赞

##### 前言： #####

分布式锁一般有三种实现方式：

1.基于数据库的乐观锁

2.基于redis的分布式锁

3.基于zookeepr的分布式锁

本文介绍第二种，基于redis的分布式锁，官方推荐用redisson，redisson支持四种连接方式，文中写了两种一个是单体，一个是集群

Cluster集群,Sentinel哨兵,Master/Slave主从,Single单体

##### 代码：自己搭建一个springboot工程    #####

代码中有详细注释，就不介绍具体方法了

首先写一个属性配置类，用来注入redis锁的一些配置信息:

package com.xhx.springboot.properties;
    
    import org.springframework.boot.context.properties.ConfigurationProperties;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.context.annotation.PropertySource;
    
    /**
     * xuhaixing
     * 2018/7/2 18:16
     **/
    
    @ConfigurationProperties(prefix ="redisson")
    public class RedissonProperties {
        private String address;
        private String password;
        //毫秒
        private int timeout=30000;
        private int database=0;
        private String sentinelAddress;
        private int connectionPoolSize=150;
        private int connectionMiniumIdleSize=10;
        private int slaveConnectionPoolSize=300;
        private int masterConnectionPoolSize=300;
        private String[] sentinelAddresses;
        private String[] masterAddresses;
        //毫秒
        private int scanInterval=2000;
        private String masterName;
    
        public String[] getMasterAddresses() {
            return masterAddresses;
        }
    
        public void setMasterAddresses(String[] masterAddresses) {
            this.masterAddresses = masterAddresses;
        }
    
        public int getScanInterval() {
            return scanInterval;
        }
    
        public void setScanInterval(int scanInterval) {
            this.scanInterval = scanInterval;
        }
    
        public int getMasterConnectionPoolSize() {
            return masterConnectionPoolSize;
        }
    
        public void setMasterConnectionPoolSize(int masterConnectionPoolSize) {
            this.masterConnectionPoolSize = masterConnectionPoolSize;
        }
    
        public String getMasterName() {
            return masterName;
        }
    
        public void setMasterName(String masterName) {
            this.masterName = masterName;
        }
    
        public int getConnectionPoolSize() {
            return connectionPoolSize;
        }
    
        public void setConnectionPoolSize(int connectionPoolSize) {
            this.connectionPoolSize = connectionPoolSize;
        }
    
        public int getConnectionMiniumIdleSize() {
            return connectionMiniumIdleSize;
        }
    
        public void setConnectionMiniumIdleSize(int connectionMiniumIdleSize) {
            this.connectionMiniumIdleSize = connectionMiniumIdleSize;
        }
    
        public int getSlaveConnectionPoolSize() {
            return slaveConnectionPoolSize;
        }
    
        public void setSlaveConnectionPoolSize(int slaveConnectionPoolSize) {
            this.slaveConnectionPoolSize = slaveConnectionPoolSize;
        }
    
        public String[] getSentinelAddresses() {
            return sentinelAddresses;
        }
    
        public void setSentinelAddresses(String[] sentinelAddresses) {
            this.sentinelAddresses = sentinelAddresses;
        }
    
        public String getAddress() {
            return address;
        }
    
        public void setAddress(String address) {
            this.address = address;
        }
    
        public String getPassword() {
            return password;
        }
    
        public void setPassword(String password) {
            this.password = password;
        }
    
        public int getTimeout() {
            return timeout;
        }
    
        public void setTimeout(int timeout) {
            this.timeout = timeout;
        }
    
        public int getDatabase() {
            return database;
        }
    
        public void setDatabase(int database) {
            this.database = database;
        }
    
        public String getSentinelAddress() {
            return sentinelAddress;
        }
    
        public void setSentinelAddress(String sentinelAddress) {
            this.sentinelAddress = sentinelAddress;
        }
    }

写一个redisson.properties配置文件

redisson.address=redis://192.168.94.151:6379
    redisson.password=xuhaixing
    redisson.timeout=3000
    redisson.database=0

maven中引入redisson的包

<?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 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelVersion>4.0.0</modelVersion>
    
        <groupId>com.xhx.springboot</groupId>
        <artifactId>distribute-lock</artifactId>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>
    
        <name>distribute-lock</name>
        <description>Demo project for Spring Boot</description>
    
        <parent>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-parent</artifactId>
            <version>2.0.3.RELEASE</version>
            <relativePath/>
        </parent>
    
        <properties>
            <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
            <project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
            <java.version>1.8</java.version>
        </properties>
    
        <dependencies>
    
            <dependency>
                <groupId>org.redisson</groupId>
                <artifactId>redisson</artifactId>
                <version>3.6.5</version>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-web</artifactId>
            </dependency>
    
            <dependency>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-starter-test</artifactId>
                <scope>test</scope>
            </dependency>
            <dependency>
                <groupId>org.apache.commons</groupId>
                <artifactId>commons-lang3</artifactId>
                <version>3.7</version>
            </dependency>
    
        </dependencies>
    
        <build>
            <plugins>
                <plugin>
                    <groupId>org.springframework.boot</groupId>
                    <artifactId>spring-boot-maven-plugin</artifactId>
                </plugin>
            </plugins>
        </build>
    
    
    </project>

配置类，注入RedissonClient，程序中用RedissonClient操作锁

package com.xhx.springboot.config;
    
    import com.xhx.springboot.properties.RedissonProperties;
    import org.apache.commons.lang3.StringUtils;
    import org.redisson.Redisson;
    import org.redisson.api.RedissonClient;
    import org.redisson.config.ClusterServersConfig;
    import org.redisson.config.Config;
    import org.redisson.config.SingleServerConfig;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.autoconfigure.AutoConfigureAfter;
    import org.springframework.boot.autoconfigure.condition.ConditionalOnProperty;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    /**
     * xuhaixing
     * 2018/7/2 18:25
     **/
    @Configuration
    @AutoConfigureAfter(value = {RedissonProperties.class})
    public class RedissonAutoConfiguration {
    
        @Autowired
        private RedissonProperties redissonProperties;
    
    
        /**
         * 单体的
         * @return
         */
        @Bean
        @ConditionalOnProperty(value = "redisson.address")
        public RedissonClient redissonSingle(){
            Config config = new Config();
            SingleServerConfig serverConfig = config.useSingleServer().setAddress(redissonProperties.getAddress())
                    .setTimeout(redissonProperties.getTimeout())
                    .setDatabase(redissonProperties.getDatabase())
                    .setConnectionPoolSize(redissonProperties.getConnectionPoolSize())
                    .setConnectionMinimumIdleSize(redissonProperties.getConnectionMiniumIdleSize());
            if(StringUtils.isNotEmpty(redissonProperties.getPassword())){
                serverConfig.setPassword(redissonProperties.getPassword());
            }
            return Redisson.create(config);
        }
    
        /**
         * 集群的
         * @return
         */
        @Bean
        @ConditionalOnProperty(value = "redisson.masterAddresses")
        public RedissonClient redissonSentinel(){
            Config config = new Config();
            ClusterServersConfig serverConfig = config.useClusterServers().addNodeAddress(redissonProperties.getMasterAddresses())
                    .setTimeout(redissonProperties.getTimeout())
                    //设置集群扫描时间
                    .setScanInterval(redissonProperties.getScanInterval())
                    //主节点线程池数量
                    .setMasterConnectionPoolSize(redissonProperties.getMasterConnectionPoolSize())
                    //从节点线程池数量
                    .setSlaveConnectionPoolSize(redissonProperties.getSlaveConnectionPoolSize());
    
            if(StringUtils.isNotEmpty(redissonProperties.getPassword())){
                serverConfig.setPassword(redissonProperties.getPassword());
            }
            return Redisson.create(config);
        }
    }

封装了一个分布式锁的父类：

package com.xhx.springboot.lock;
    
    import org.redisson.api.RLock;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * xuhaixing
     * 2018/7/2 17:56
     **/
    public interface DistributedLocker {
        RLock lock(String lockKey);
        RLock lock(String lockKey,int timeout);
        RLock lock(String lockKey, TimeUnit unit,int timeout);
        boolean tryLock(String lockKey,TimeUnit unit,int waitTime,int leaseTime);
        void unlock(String lockKey);
        void unlock(RLock lock);
    }

子类：

package com.xhx.springboot.lock;
    
    import org.redisson.api.RLock;
    import org.redisson.api.RedissonClient;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.stereotype.Component;
    
    import java.util.concurrent.TimeUnit;
    
    /**
     * xuhaixing
     * 2018/7/2 18:03
     **/
    @Component
    public class RedissonDistributedLocker implements DistributedLocker {
    
        @Autowired
        private RedissonClient redissonClient;
    
        /**
         * 没有超时时间,默认30s
         * @param lockKey
         * @return
         */
        @Override
        public RLock lock(String lockKey) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock();
            return lock;
        }
    
        /**
         * 自己设置超时时间
         * @param lockKey 锁的key
         * @param timeout  秒  如果是-1，直到自己解锁，否则不会自动解锁
         * @return
         */
        @Override
        public RLock lock(String lockKey, int timeout) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock(timeout, TimeUnit.SECONDS);
            return lock;
        }
    
        @Override
        public RLock lock(String lockKey, TimeUnit unit, int timeout) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock(timeout,unit);
            return lock;
        }
    
        /**
         *
         * @param lockKey  锁key
         * @param unit  锁单位
         * @param waitTime   等到最大时间，强制获取锁
         * @param leaseTime  锁失效时间
         * @return
         */
        @Override
        public boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {
            RLock lock = redissonClient.getLock(lockKey);
            try {
                return lock.tryLock(waitTime,leaseTime,unit);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            return false;
        }
    
        @Override
        public void unlock(String lockKey) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.unlock();
        }
    
        @Override
        public void unlock(RLock lock) {
            lock.unlock();
        }
    
    }

启动类：

package com.xhx.springboot;
    
    import com.xhx.springboot.properties.RedissonProperties;
    import org.redisson.api.RedissonClient;
    import org.springframework.boot.SpringApplication;
    import org.springframework.boot.autoconfigure.SpringBootApplication;
    import org.springframework.boot.context.properties.EnableConfigurationProperties;
    import org.springframework.context.annotation.PropertySource;
    
    @SpringBootApplication
    @PropertySource(value = {"classpath:redisson.properties"})
    @EnableConfigurationProperties(value = {RedissonProperties.class})
    public class DistributeLockApplication {
    
        public static void main(String[] args) {
            SpringApplication.run(DistributeLockApplication.class, args);
        }
    }

测试类：

package com.xhx.springboot;
    
    import com.xhx.springboot.lock.RedissonDistributedLocker;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.TimeUnit;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.DEFINED_PORT)
    public class DistributeLockApplicationTests {
    
        @Autowired
        private RedissonDistributedLocker redissonLocker;
    
        @Test
        public void contextLoads() throws Exception {
            int count = 10;
            CountDownLatch latch = new CountDownLatch(count);
            for (int i = 0; i < count; i++) {
                Thread thread = new Thread(() -> {
                    try {
                        String lockKey = "17631701110";
                        redissonLocker.tryLock(lockKey, TimeUnit.SECONDS, 100, 8);
                        System.out.println("===加锁===" + Thread.currentThread().getName());
    
                        System.out.println("===做自己操作===");
                        Thread.sleep(5000);
    
                        System.out.println("===释放锁===" + Thread.currentThread().getName());
                        redissonLocker.unlock(lockKey);
    
                        System.out.println(latch.getCount());
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    latch.countDown();
                });
                thread.start();
    
            }
            latch.await();
        }
    
    }

程序执行结果：

![70][]

[我的github代码地址][github]

[70]: /images/20220521/3c1403039bb4410e8870176c3d2c2356.png
[github]: https://github.com/xuhaixing/myDocument.git