Redisson 完成分布式锁

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

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

    /**
     * 车库停车
     * 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"+"班的人走了";
    }