1, Distributed lock characteristics

When designing distributed locks, you should consider at least some conditions that distributed locks must meet:
1. Mutual exclusion: under the condition of distributed high concurrency, only one thread can obtain a lock at the same time, which is the most basic point;
2. Deadlock: under the condition of distributed high concurrency, if a thread obtains a lock, then hangs, and does not release the lock, so that other threads can never obtain the lock, this is a deadlock. Distributed locks must avoid deadlock;
3. Performance: for shared resources with a large number of accesses, you need to consider reducing the lock waiting time to avoid causing a large number of thread blocking. When designing the lock, it is necessary to consider that the granularity of the lock should be as small as possible and the range of the lock should be as small as possible;
4. Reentrant: the same thread can repeatedly get the lock of the same resource. Reentry lock is very conducive to the efficient utilization of resources.

2, Comparison of Redis, Redis lua scripts and redistribute locking

3, Redisson principle analysis

1. Acquire lock

/**

• Attempt to acquire lock
• @param lockKey
• @param unit time unit
• @param waitTime maximum wait time
• @param leaseTime automatic release time after locking
• @return

*/
public static boolean tryLock(String lockKey, TimeUnit unit, int waitTime, int leaseTime) {

RLock lock = redissonClient.getLock(lockKey);
try {
    return lock.tryLock(waitTime, leaseTime, unit);
} catch (InterruptedException e) {
    return false;
}

}

2. Release the lock

/**

• Release lock
• @param lockKey locks resources

*/
public static void unlock(String lockKey) {

RLock lock = redissonClient.getLock(lockKey);
lock.unlock();

}

From the above figure, we can see that redisson locking and unlocking Lua scripts are the most important components of redisson distributed lock implementation

3. Interpretation of redistribution locking Lua script

4, Redisson common locks

1. Reentrant Lock the RLock Java object of Redisson's distributed Reentrant Lock implements the java.util.concurrent.locks.Lock interface and supports automatic expiration unlocking

public void testReentrantLock(RedissonClient redisson) {

RLock lock = redisson.getLock("anyLock");
try {
    // 1. The most common usage
    // lock.lock();
    // 2. It supports the expiration unlocking function. It will be unlocked automatically after 10 seconds without calling the unlock method to unlock manually
    // lock.lock(10, TimeUnit.SECONDS);
    // 3. Try to lock, wait up to 3 seconds, and unlock automatically 10 seconds after locking
    boolean res = lock.tryLock(3, 10, TimeUnit.SECONDS);
    if (res) { // success
        // do your business
    }
} catch (InterruptedException e) {
    e.printStackTrace();
} finally {
    lock.unlock();
}

}

2. Async hronous Redisson also provides methods for asynchronous execution of distributed locks

public void testAsyncReentrantLock(RedissonClient redisson) {

RLock lock = redisson.getLock("anyLock");
try {
    lock.lockAsync();
    lock.lockAsync(10, TimeUnit.SECONDS);
    Future<Boolean> res = lock.tryLockAsync(3, 10, TimeUnit.SECONDS);
    if (res.get()) {
        // do your business
    }
} catch (InterruptedException e) {
    e.printStackTrace();
} catch (ExecutionException e) {
    e.printStackTrace();
} finally {
    lock.unlock();
}

}

3. Fair Lock Redisson distributed reentrant Fair Lock is also an RLock object that implements the java.util.concurrent.locks.Lock interface. While providing the automatic expiration unlocking function, it ensures that when multiple Redisson client threads request locking at the same time, they are preferentially allocated to the thread that makes the request first.

public void testFairLock(RedissonClient redisson){

RLock fairLock = redisson.getFairLock("anyLock");  
try{  
    // Most common usage  
    fairLock.lock();  
    // It supports the expiration unlocking function. It will be unlocked automatically after 10 seconds without calling the unlock method to unlock manually  
    fairLock.lock(10, TimeUnit.SECONDS);  
    // Try to lock, wait for 100 seconds at most, and unlock automatically 10 seconds after locking  
    boolean res = fairLock.tryLock(100, 10, TimeUnit.SECONDS);  
    if (res) {
        // do your business
    }
} catch (InterruptedException e) {  
    e.printStackTrace();  
} finally {  
    fairLock.unlock();  
}  

}

4. Interlock (MultiLock) the RedissonMultiLock object of Redisson can associate multiple RLock objects into an interlock, and each RLock object instance can come from different Redisson instances

public void testMultiLock(RedissonClient redisson1,RedissonClient redisson2, RedissonClient redisson3){

RLock lock1 = redisson1.getLock("lock1");  
RLock lock2 = redisson2.getLock("lock2");  
RLock lock3 = redisson3.getLock("lock3");  
RedissonMultiLock lock = new RedissonMultiLock(lock1, lock2, lock3);  
try {  
    // Lock at the same time: lock1 lock2 lock3. All locks are locked successfully.  
    lock.lock();  
    // Try to lock, wait for 100 seconds at most, and unlock automatically 10 seconds after locking  
    boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);  
    if (res) {
        // do your business
    }
} catch (InterruptedException e) {  
    e.printStackTrace();  
} finally {  
    lock.unlock();  
}  

}

5. Red lock the RedissonRedLock object of Redisson implements the locking algorithm introduced by redlock. This object can also be used to associate multiple RLock objects into a red lock. Each RLock object instance can come from a different Redisson instance

public void testRedLock(RedissonClient redisson1,RedissonClient redisson2, RedissonClient redisson3){

RLock lock1 = redisson1.getLock("lock1");  
RLock lock2 = redisson2.getLock("lock2");  
RLock lock3 = redisson3.getLock("lock3");  
RedissonRedLock lock = new RedissonRedLock(lock1, lock2, lock3);  
try {  
    // Lock at the same time: lock1, lock2, lock3. If the red lock is successfully locked on most nodes, it will be successful.  
    lock.lock();  
    // Try to lock, wait for 100 seconds at most, and unlock automatically 10 seconds after locking  
    boolean res = lock.tryLock(100, 10, TimeUnit.SECONDS);  
    if (res) {
        // do your business
    }
} catch (InterruptedException e) {  
    e.printStackTrace();  
} finally {  
    lock.unlock();  
}  

}