再也不用担心面试官让我用Redis实现分布式锁啦(二、Redisson实现分布式锁)

曾经终败给现在 2023-02-16 06:44 25阅读 0赞

**目录**

一、Jedis实现分布式锁

二、Redisson实现分布式锁（单机Redis）

一、引入依赖(3.5.7)

二、配置redis

三、配置RedisonConfig

四、提供锁接口及实现，方便统一调用

五、提供测试接口，测试分布式锁

--------------------

# [一、Jedis实现分布式锁][Jedis] #

# 二、Redisson实现分布式锁（单机Redis）  #

##      一、引入依赖(3.5.7) ##

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

##      二、配置redis ##

spring.redis.database=1
    ## redis host
    spring.redis.host=localhost
    ## redis port
    spring.redis.port=6379
    ## redis password
    spring.redis.password=123456
    ## redis password
    spring.redis.timeout=30000
    ## redis pool
    spring.redis.jedis.pool.max-active=500
    spring.redis.jedis.pool.max-idle=1000
    spring.redis.jedis.pool.max-wait=6000ms
    spring.redis.jedis.pool.min-idle=4

##      三、配置RedisonConfig ##

@Component
    @ConfigurationProperties(prefix = "spring.redis")
    @Data
    public class RedisProperties {
    
        /** IP */
        private String host;
        /** 端口 */
        private String port;
        /** 密码 */
        private String password;
    
    }

@Configuration
    public class RedissonConfig {
    
        @Autowired
        private RedisProperties redisProperties;
    
        // 单机模式
        @Bean
        public RedissonClient getRedisson(){
            Config config = new Config();
            config.useSingleServer().setAddress("redis://" + redisProperties.getHost() + ":" + redisProperties.getPort())
                    .setPassword(redisProperties.getPassword());
            return Redisson.create(config);
        }
    
    }

##      四、提供锁接口及实现，方便统一调用 ##

public interface DistributedLocker {
    
        RLock lock(String lockKey);
    
        RLock lock(String lockKey, long timeout);
    
        RLock lock(String lockKey, TimeUnit unit, long timeout);
    
        boolean tryLock(String lockKey, TimeUnit unit, long waitTime, long leaseTime);
    
        void unlock(String lockKey);
    
        void unlock(RLock lock);
    
    
    }

@Component
    public class RedissonDistributedLocker implements DistributedLocker {
    
        @Autowired
        private RedissonClient redissonClient;
    
        /**
         * lock(), 拿不到lock就不罢休，不然线程就一直block
         * @param lockKey
         * @return
         */
        @Override
        public RLock lock(String lockKey) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock();
            return lock;
        }
    
        /**
         * leaseTime为加锁时间，单位为秒
         * @param lockKey
         * @param leaseTime
         * @return
         */
        @Override
        public RLock lock(String lockKey, long leaseTime) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock(leaseTime, TimeUnit.SECONDS);
            return lock;
        }
    
    
        /**
         * timeout为加锁时间，时间单位由unit确定
         * @param lockKey
         * @param unit
         * @param timeout
         * @return
         */
        @Override
        public RLock lock(String lockKey, TimeUnit unit ,long timeout) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.lock(timeout, unit);
            return lock;
        }
    
        /**
         * tryLock()，马上返回，拿到lock就返回true，不然返回false.
         * 带时间限制的tryLock()，拿不到lock，就等一段时间，超时返回false.
         * @param lockKey
         * @param unit
         * @param waitTime
         * @param leaseTime
         * @return
         */
        @Override
        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 e) {
                return false;
            }
        }
    
        /**
         * 释放锁
         * @param lockKey
         */
        @Override
        public void unlock(String lockKey) {
            RLock lock = redissonClient.getLock(lockKey);
            lock.unlock();
        }
    
        /**
         * 释放锁
         * @param lock
         */
        @Override
        public void unlock(RLock lock) {
            lock.unlock();
        }
    
    
    }

##      五、 提供测试接口，测试分布式锁 ##

@RequestMapping("/testRedisson")
        public void redissonTest() {
            String key = "redisson_key";
            for (int i = 0; i < 10; i++) {
                Thread t = new Thread(() -> {
                    try {
                        logger.error("=============线程开启============"+Thread.currentThread().getName());
                        boolean isGetLock =  distributedLocker.tryLock(Constants.redisTestKey(key), TimeUnit.SECONDS,5L,10L); //尝试获取锁，等待5秒，自己获得锁后一直不解锁则10秒后自动解锁
                        if(isGetLock){
                            Thread.sleep(100); //获得锁之后可以进行相应的处理
                            logger.error("======获得锁后进行相应的操作======"+Thread.currentThread().getName());
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }finally {
                        distributedLocker.unlock(key);
                    }
                });
                t.start();
            }
        }

[Jedis]: https://blog.csdn.net/ls490447406/article/details/105639856