分布式锁解决方案——redisson的使用

概述

redisson：

​ 提供基于redis的分布式服务，包含很多，本文详细介绍 springboot 下的分布式锁的使用

​ 学过JUC的话，可以无缝的转换到redisson，因为redisson实现了Lock接口，并且功能很强大

​

配置

配置好redis 后再进行以下操作

依赖

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

配置类：单节点模式

import org.redisson.Redisson;
import org.redisson.api.RedissonClient;
import org.redisson.config.Config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class MyRedissonConfig {

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson() {
        Config config = new Config();
        config.useSingleServer().setAddress("redis://localhost:6379");
        RedissonClient redissonClient = Redisson.create(config);
        return redissonClient;
    }
}

测试

使用

Lock 锁（可重入锁）

    void lockTest() {
        // 获取一把锁：只要名字一样，就是同一把锁
        RLock lock = redisson.getLock("yh-lock");

        // 加锁
        /**
         * 默认加锁30s，如果业务没做完，会自动续期
         * 但如果指定时间，就不会自动续期
         */
        lock.lock(30, TimeUnit.SECONDS); // 最佳实践
        try {
            System.out.println("加锁成功，实现业务...");
        } finally {
            // 解锁: 无论如何都要解锁
            /**
             * 即使停机导致解锁代码没有运行，redisson也不会出现死锁、
             *
             */
            System.out.println("释放锁");
            lock.unlock();
        }
    }

公平锁

    public void fairLockTest() {
        RLock fairLock = redisson.getFairLock("f-lock");
        fairLock.lock();
        fairLock.unlock();
    }

读写锁

写锁

    public void wLockTest() {
        // 获取读写锁
        RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");

        // 写锁
        RLock rLock = lock.writeLock();
        rLock.unlock();  // 释放写锁
    }

读锁

    public void rLockTest() {
        // 读取读写锁
        RReadWriteLock lock = redisson.getReadWriteLock("rw-lock");

        // 读锁
        RLock rLock = lock.readLock();
        rLock.unlock();
    }

闭锁

    @Test
    public void doorLockTest() throws InterruptedException {
        // 获取闭锁
        RCountDownLatch lock = redisson.getCountDownLatch("cd-lock");

        lock.trySetCount(5); // 设置计数，若计数清零闭锁自动关闭
        lock.await(); // 等待计数清零

        System.out.println("闭锁关闭后的业务逻辑...");
    }
    
    @Test
    public void goTest() {
        RCountDownLatch lock = redisson.getCountDownLatch("cd-lock");
        lock.countDown(); // 计数减一
    }

信号量测试

    public void park() throws InterruptedException {
        redisTemplate.opsForValue().set("park", "5"); // redis里设置5个车位
        RSemaphore park = redisson.getSemaphore("park");

//        park.acquire(); // 占一个车位
        boolean flag = park.tryAcquire();// 尝试占一个车位，有车位就true
        if (flag) {

        } else {

        }
    }

    public void parkGoTest() {
        RSemaphore park = redisson.getSemaphore("park");
        park.release(); // 释放一个车位，计数减一
    }