Redisson 完成分布式锁

1、简介

Redisson 是架设在 Redis 基础上的一个 Java 驻内存数据网格（In-Memory Data Grid）。充分 的利用了 Redis 键值数据库提供的一系列优势，基于 Java 实用工具包中常用接口，为使用者 提供了一系列具有分布式特性的常用工具类。使得原本作为协调单机多线程并发程序的工 具包获得了协调分布式多机多线程并发系统的能力，大大降低了设计和研发大规模分布式 系统的难度。同时结合各富特色的分布式服务，更进一步简化了分布式环境中程序相互之间 的协作。

2、配置

pom依赖

    org.redisson
    redisson
    3.12.0

 @bean注入配置

@Configuration
public class MyRedissonConfig {

    @Bean(destroyMethod = "shutdown")
    public RedissonClient redisson(){
        //1.创建配置
        Config config = new Config();
        //Redis url should start with redis:// or rediss:// (for SSL connection)
        config.useSingleServer().setAddress("redis://192.168.107.134:6379");
        return Redisson.create(config);
    }
}

3、使用分布式锁 

可重入锁

    @ResponseBody
    @GetMapping("/hello")
    public  String hello(){
        //1.获取一把锁，只要锁命一样，就是同一把锁
        RLock lock = redissonClient.getLock("mylock");
        //2.加锁
        // 1).锁的自动续期，运行期间自动的给锁续上新的30s，不用担心业务时间长，锁自动过期被删掉
        // 2).加锁的业务只要完成就不会给当前的锁续期，即使不手动释放，锁默认在30s以后会自动删除
//        lock.lock();//阻塞式等待
        lock.lock(10, TimeUnit.SECONDS);//10s后自动解锁，自动解锁时间一定要大于业务的执行时间
        //问题： lock.lock(10, TimeUnit.SECONDS);/ 在锁时间到期以后，不会自动续期
        //1.如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时加就是我们指定的时间
        //2.如果为指定的锁的超时时间，就使用看门狗的超时时间30s 30*1000
        //      只要占锁成功，就会启动一个定时任务【重新给锁设置时间，新的过期时间就是看门狗的默认时间】
        //      1/3[10s]就会续期一次。 30/3=10s

        //最佳实战 lock.lock(10, TimeUnit.SECONDS);省掉了整个续期操作：手动解锁
        try {
            System.out.println("加锁成功，执行业务...."+Thread.currentThread().getId());
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            //3.解锁
            //假设解锁代码没有执行，redisson会不会出现死锁--
            System.out.println("释放锁..."+Thread.currentThread().getId());
            lock.unlock();
        }
        return "hello";
    }

//1.获取一把锁，只要锁命一样，就是同一把锁

//2.加锁
// 1).锁的自动续期，运行期间自动的给锁续上新的30s，不用担心业务时间长，锁自动过期被删掉
// 2).加锁的业务只要完成就不会给当前的锁续期，即使不手动释放，锁默认在30s以后会自动删除

 

//问题： lock.lock(10, TimeUnit.SECONDS);/ 在锁时间到期以后，不会自动续期
//1.如果我们传递了锁的超时时间，就发送给redis执行脚本，进行占锁，默认超时加就是我们指定的时间
//2.如果为指定的锁的超时时间，就使用看门狗的超时时间30s 30*1000
//      只要占锁成功，就会启动一个定时任务【重新给锁设置时间，新的过期时间就是看门狗的默认时间】
//      1/3[10s]就会续期一次。 30/3=10s

//最佳实战 lock.lock(10, TimeUnit.SECONDS);省掉了整个续期操作：手动解锁

//3.解锁
//假设解锁代码没有执行，redisson会不会出现死锁--

读写锁 

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

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

 @ResponseBody
    @GetMapping("/write")
    public String write() throws InterruptedException {

        String s="";
        //1.改数据加写锁，读数据加读锁
        RReadWriteLock rwLock = redissonClient.getReadWriteLock("rwLock");
        RLock rLock = rwLock.writeLock();
        try {
            s = UUID.randomUUID().toString();
            redisTemplate.opsForValue().set("writeValue",s);
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            rLock.unlock();
        }

        Thread.sleep(30000);

        return  s;
    }


    @ResponseBody
    @GetMapping("/read")
    public String read() throws InterruptedException {
        String s="";

        RReadWriteLock rwLock = redissonClient.getReadWriteLock("rwLock");
        RLock rLock = rwLock.readLock();
        rLock.lock();
        try {
            s= redisTemplate.opsForValue().get("writeValue");

        }catch (Exception e) {
            e.printStackTrace();
        }finally {
            rLock.unlock();
        }
        return  s;
    }

//保证一定能读到最新数据，修改期间写锁是一个互斥锁，排他锁 ，读锁是一个共享锁
//写锁没释放，读锁必须等待
//读+读 相当于无锁，只会在redis中记录好，所有当前的读锁，他们都会同时加锁成功。
//写+读 等待写锁释放
//写+写 阻塞方式
//读+写 有读锁，写也必须等待
//只要有写的存在，都必须等待

信号量 

基于Redis的Redisson的分布式信号量（Semaphore）Java对象RSemaphore采用了与java.util.concurrent.Semaphore相似的接口和用法。同时还提供了异步（Async）、反射式（Reactive）和RxJava2标准的接口。 

    /**
     * 车库停车
     * 3车位
     */
    @ResponseBody
    @GetMapping("/park")
    public String park(){

        RSemaphore park = redissonClient.getSemaphore("park");
        try {
            park.acquire();//获取一个信号量，获取一个值,占一个车位
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        return "ok";
    }

    @ResponseBody
    @GetMapping("/go")
    public String go(){
        RSemaphore park = redissonClient.getSemaphore("park");
        park.release();//释放车位
        return "ok";
    }

闭锁

   /**
     * 放假锁门
     * 5个班全部走人以后，我们可以锁大门
     */
    @GetMapping("lockDoor")
    @ResponseBody
    public String lockDoor() throws InterruptedException {
        RCountDownLatch door = redissonClient.getCountDownLatch("door");
        door.await();//等待闭锁完成

        return  "放假了";
    }


    @GetMapping("/gogogo/{id}")
    @ResponseBody
    public String gogogo(@PathVariable("id") Long id){
        RCountDownLatch door = redissonClient.getCountDownLatch("door");
        door.countDown();//计数减一
        return "id"+"班的人走了";
    }