Implementation of distributed lock

1. What is distributed lock

   In order to ensure the consistency of data in the concurrent environment , We usually use locking . If the data only exists on one server , The problem of inconsistent data can be solved by using a single lock .
   In distributed clusters , The value of a variable may be shared by multiple nodes of a cluster , At this time, to ensure the consistency of variables , It is not enough to lock only one machine , What we need to do is lock the cluster , This is the distributed lock .

2. Conditions for implementing distributed locks

• In the distributed system environment , The critical area that is locked can only be executed by one thread of a node at the same time
• Acquiring and releasing locks require high availability
• Reentrancy needs to be guaranteed
• Lock failure mechanism , Prevent deadlock
• Non blocking features are required , If the lock is not obtained within a certain period of time, it will directly return to the failure of obtaining the lock

3. Three ways to realize distributed lock

3.1 be based on Redis Implement distributed locks

1. When getting the lock , Use setnx Lock , That is to say redis A lock record is stored in , And use expire Command to add a timeout to the lock , After that time, the lock will be released automatically , The lock value Value is a randomly generated UUID, Judge when releasing the lock through this .
2. When acquiring the lock, a timeout for acquiring is also set , If it exceeds this time, give up acquiring lock .
3. When you release the lock , adopt UUID Decide whether to lock , If it's time to lock , execute delete Lock release .

3.2 Implementation of distributed lock based on Database

   If not used Redis And a series of caching middleware , You can also use databases to implement distributed locks , Store the lock record in the database .
   This is not recommended , Because you need to implement the timeout logic by yourself , The throughput of accessing the database at the same time is not as good as that of caching , It is difficult to ensure high availability in an environment of high concurrency and competitive locks .

3.3 be based on zookeeper Implement distributed locks

1. Create a directory mylock;
2. Threads A To get the lock is in mylock Create temporary order node under directory ;
3. obtain mylock All child nodes in the directory , Then get the smaller brother node , If it doesn't exist , It means that the front line The sequence number of Chengshun is the smallest , Gets the lock ;
4. Threads B Get all nodes , Judge that you are not the smallest node , Set a node smaller than yourself to listen to ;
5. Threads A processed , Delete your own node , Threads B A change event was detected , Judge whether you are the smallest node , If so, get the lock .

4. be based on Redis Code example of implementing distributed lock

  /** *  Lock operation  */
  private void lock() {
    
	  String id = UUID.randomUUID().toString();
	  // randomId：ThreadLocal Variable , Storage thread UUID, With global uniqueness 
      randomId.set(id);
      try {
    
      	  //  Lock taking timeout ：65 * 500 ms
          tryLock(id, 65);
      } catch (Exception e) {
    
         log.error("lock fail", e);
     }
  }
    	
  private void tryLock(String val, int repeatTimes) throws Exception {
    
  	  // redis client 
      CacheProvider cacheProvider = CRedisClient.getCacheProvider();
	  // locked：ThreadLocal Variable , Record whether the current thread has a lock , Ensure reentry 
      if (!Objects.isNull(locked.get())) {
    
          return;
      }
      //  Lock record timeout ：30 s
      if (!cacheProvider.set(LOCK, val, "NX", "EX", 30)) {
    
          if (repeatTimes > 0) {
    
              Thread.sleep(500);
              tryLock(val, repeatTimes - 1);
          } else {
    
              //  Check for abnormalities 
              long ttl = cacheProvider.ttl(LOCK);
              if (ttl > 30 || ttl == -1) {
    
                  cacheProvider.del(LOCK);
              }
              throw new TimeoutException("try lock time out");
          }
      } else{
    
          locked.set(true);
      }
  }

  /** *  Unlock operation  */
  private void unlock()  {
    
      CacheProvider cacheProvider = CRedisClient.getCacheProvider();
      String expected = randomId.get();
      String actual = cacheProvider.get(LOCK);
      //  confirm unlock Identity of the thread 
      if (Objects.equals(expected, actual)) {
    
          cacheProvider.del(LOCK);
      }
      locked.remove();
  }