Redistribution distributed lock types

be based on Redis Of Redisson The distributed reentrant lock realizes java.util.concurrent.locks.Lock Interface

Redisson  The types of locks are as follows ： Reentrant lock , Fair lock , interlocking , Red lock , Read-write lock , Next, we will introduce each lock in detail .

• Reentrant lock
  
  A thread is executing a method with a lock , This method calls another method that needs the same lock , Then the thread can directly execute the called method , Without having to reacquire the lock .
   

      public void method1() {
          RLock lock = redissonClient.getLock("lock");
          try {
              lock.lock();
              method2();
          } finally {
              lock.unlock();
          }
  
          System.out.println(" Lock release successful ");
  
      }
  
      public void method2() {
          RLock lock = redissonClient.getLock("lock");
          try {
              if (lock.tryLock()) {
                  System.out.println(" Locking success ");
                  // Business logic 
              }
          } finally {
              lock.unlock();
          }
      }

• Fair lock  
  
  It's guaranteed to be multiple Redisson When a client line requests a lock at the same time , Priority is given to the thread that made the request first . All request threads will be queued in a queue , When a thread goes down ,Redisson Will wait for 5 Seconds to continue to the next thread , That is to say, if there is 5 All threads are waiting , Then the next thread will wait for at least 25 second .
   

  RLock fairLock = redisson.getFairLock("anyLock");
  //  The most common use method 
  fairLock.lock();

•   interlocking ​​​​​​​

        When you can associate multiple lock objects with one lock object
​​​​​​

• RLock lock1 = redissonInstance1.getLock("lock1");
  RLock lock2 = redissonInstance2.getLock("lock2");
  RLock lock3 = redissonInstance3.getLock("lock3");
  
  RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);
  //  At the same time lock ：lock1 lock2 lock3
  //  Success is only when all the locks are locked .
  lock.lock();
  
  // Business logic 
  lock.unlock();

• Red lock  

        When there are most （ More than half ） After locking successfully , To really get the lock

RLock lock1 = redissonInstance1.getLock("lock1");
RLock lock2 = redissonInstance2.getLock("lock2");
RLock lock3 = redissonInstance3.getLock("lock3");

RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);
//  At the same time lock ：lock1 lock2 lock3
//  A red lock is successful if it locks most nodes .  Here you are 3 A lock , At least 2 One lock succeeded , It's really successful to lock 
lock.lock();
...
lock.unlock();

• Read-write lock

    When reading a lock, multiple threads can obtain , Write lock can only be obtained by one thread , After testing, when the write lock has not been released , Read lock blocking cannot be obtained , Until the write lock is released .
 

/**
 *  Make sure you can read the latest data , During revision , Writing lock is an exclusive lock （ The mutex ）. Read lock is a shared lock 
 *  The lock is not released , You have to wait to read 
 */
@GetMapping("/read")
@ResponseBody
public String readValue() {

    RReadWriteLock readWriteLock = redisson.getReadWriteLock("rw-lock");
    RLock rLock = readWriteLock.readLock();
    try {
        rLock.lock();
    } catch (Exception e) {
        e.printStackTrace();
    } finally {
        rLock.unlock();
    }
    return "";
}


@GetMapping("/write")
@ResponseBody
public String writeValue() {

    RReadWriteLock readWriteLock = redisson.getReadWriteLock("rw-lock");
    RLock rLock = readWriteLock.writeLock();
    try {
        //1、 Change data and add write lock , Read data and add read lock 
        rLock.lock();
        TimeUnit.SECONDS.sleep(10000);
    } catch (InterruptedException e) {
        e.printStackTrace();
    } finally {
        rLock.unlock();
    }
    return "";
}