Implementation of reliable distributed locks redlock and redisson

1. introduction

In the previous article , We introduced in detail based on redis Implementation of distributed transaction lock based on ：

much , There are so many holes in the distributed lock

We see , How to improve the distributed lock scheme step by step and finally realize its high availability .

But then “ High availability ” Come on , It still seems to be lacking , That is, if what he relies on redis It's a single point , If something goes wrong , Then the distributed locks of the whole business will not be used , Even if we are going to order redis Upgrade to redis Master slave mode or cluster , For fixed key Come on ,master Nodes still exist independently , Due to the time interval of master-slave synchronization , If in the meantime master Node failure ,slaver The node is elected master node , that ,master The distributed lock information stored on the node may be lost , Thus creating competitive conditions .

that , How to avoid this situation ？

redis Officials have given based on multiple redis High availability distributed lock solution for cluster deployment — RedLock, In this article, we will introduce in detail .

2. RedLock The process of adding and unlocking

Based on the above theory , We know ,RedLock It's in multiple Redis The implementation of a distributed lock deployed on a cluster , He effectively avoided the single point problem .

Suppose we have N individual Redis Service or cluster ,RedLock The locking process of is as follows ：

1. client Get the current millisecond time stamp , And set the timeout TTL
2. In order to N individual Redis The service makes a request , Use a that is globally unique value To apply for the lock key
3. If from N/2+1 individual redis The lock is obtained successfully in the service , that , The acquisition of the distributed lock is considered successful , Otherwise, it will be regarded as failure to acquire the lock .
4. If the lock acquisition fails , Or execute to TTL, To all Redis Services all send unlock requests .

3. Java Realization — redisson

java In language ,redisson The package implements the redlock Encapsulation , Mainly through redis client And lua Script implementation , Why lua Script , It is to realize the transaction of adding and unlocking verification and execution .

You were right on the previous homepage redis combination lua There is an article about implementing strict transactions , You can refer to ：

Redis Affairs and Redis Lua Script writing

3.1 only ID Generation

Distributed transaction locks , In order to let the storage node as the central node know the lock holder , So as to prevent the lock from being unlocked by non holder , Each person who initiated the request client All nodes must have globally unique id.

Usually we use UUID As the only id,redisson That's how it works , On this basis ,redisson Also joined the threadid Avoid multiple threads repeatedly getting UUID Loss of performance ：

protected final UUID id = UUID.randomUUID();
String getLockName(long threadId) {
    return id + ":" + threadId;
}

Copy

3.2 Lock logic

redisson The core code of locking is very easy to understand , By passing in TTL And the only id, Implement a lock request for a period of time .

The following is the implementation logic of reentrant lock ：

<T> RFuture<T> tryLockInnerAsync(long leaseTime, TimeUnit unit, long threadId, RedisStrictCommand<T> command) {
    internalLockLeaseTime = unit.toMillis(leaseTime);
    //  When getting the lock 5 individual redis The command sent by the instance 
    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, command,
              //  Verify the of distributed locks KEY Does it already exist , If it doesn't exist , Then perform hset command （hset REDLOCK_KEY uuid+threadId 1）, And pass pexpire Set the expiration time （ It's also the lease time of the lock ）
              "if (redis.call('exists', KEYS[1]) == 0) then " +
                  "redis.call('hset', KEYS[1], ARGV[2], 1); " +
                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              //  If distributed locks KEY Already exists , Then the verification is unique  id, If only  id  matching , Represents the lock held by the current thread , Then the number of reentries plus 1, And set the failure time 
              "if (redis.call('hexists', KEYS[1], ARGV[2]) == 1) then " +
                  "redis.call('hincrby', KEYS[1], ARGV[2], 1); " +
                  "redis.call('pexpire', KEYS[1], ARGV[1]); " +
                  "return nil; " +
              "end; " +
              //  Get distributed lock KEY In milliseconds 
              "return redis.call('pttl', KEYS[1]);",
              // KEYS[1]  Corresponding to distributed locks  key;ARGV[1]  Corresponding  TTL;ARGV[2]  It's unique  id
                Collections.<Object>singletonList(getName()), internalLockLeaseTime, getLockName(threadId));
}

Copy

3.3 Release lock logic

protected RFuture<Boolean> unlockInnerAsync(long threadId) {
    //  towards 5 individual redis All instances execute the following commands 
    return commandExecutor.evalWriteAsync(getName(), LongCodec.INSTANCE, RedisCommands.EVAL_BOOLEAN,
            //  If distributed locks  KEY  non-existent , So  channel  Post a message 
            "if (redis.call('exists', KEYS[1]) == 0) then " +
                "redis.call('publish', KEYS[2], ARGV[1]); " +
                "return 1; " +
            "end;" +
            //  If the distributed lock exists , But the only  id  Mismatch , Indicates that the lock has been occupied 
            "if (redis.call('hexists', KEYS[1], ARGV[3]) == 0) then " +
                "return nil;" +
            "end; " +
            //  If the current thread holds the distributed lock , Then reduce the number of reentry times  1
            "local counter = redis.call('hincrby', KEYS[1], ARGV[3], -1); " +
            //  Less reentry times 1 If the latter value is greater than 0, Indicates that the distributed lock has been re entered , Then only set the failure time , Don't delete 
            "if (counter > 0) then " +
                "redis.call('pexpire', KEYS[1], ARGV[2]); " +
                "return 0; " +
            "else " +
                //  Less reentry times 1 If the latter value is 0, Then delete the lock , And release the unlock message 
                "redis.call('del', KEYS[1]); " +
                "redis.call('publish', KEYS[2], ARGV[1]); " +
                "return 1; "+
            "end; " +
            "return nil;",
            // KEYS[1]  Indicates the of the lock  key,KEYS[2]  Express  channel name,ARGV[1]  Indicates an unlock message ,ARGV[2]  Express  TTL,ARGV[3]  It means only  id
            Arrays.<Object>asList(getName(), getChannelName()), LockPubSub.unlockMessage, internalLockLeaseTime, getLockName(threadId));

}

Copy

4. redisson RedLock Use

redisson The implementation of distributed locks is very simple to use ：

Config config = new Config();
config.useSentinelServers().addSentinelAddress("127.0.0.1:6369","127.0.0.1:6379", "127.0.0.1:6389")
        .setMasterName("masterName")
        .setPassword("password").setDatabase(0);
RedissonClient redissonClient = Redisson.create(config);
RLock redLock = redissonClient.getLock("REDLOCK_KEY");
boolean isLock;
try {
    isLock = redLock.tryLock(500, 10000, TimeUnit.MILLISECONDS);
    if (isLock) {
        //TODO if get lock success, do something;
    }
} catch (Exception e) {
} finally {
    redLock.unlock();
}

Copy

You can see , because redisson In the implementation of the package , adopt lua The script verifies the... When unlocking client identity , So we don't have to finally To determine whether locking is successful , There is no need for additional identity verification , It can be said that it has reached the level of out of the box .

5. redisson Advanced features of

5.1 Handling of abnormal conditions

One of the most common problems with distributed transaction locks is if the lock has been acquired client stay TTL Failed to complete the processing of competitive resources within the time , At this time, the lock will be automatically released , Cause competitive conditions to occur .

In this case, if client Set the timer task at the end to automatically extend the lock occupation time , Can cause client Complexity and redundancy of end logic .

redisson In the process of implementation , Naturally, this problem is also taken into account ,redisson Provides a “ watchdog ” Optional features , And added lockWatchdogTimeout Configuration parameters , The watchdog thread will automatically lockWatchdogTimeout After timeout, the lock occupation time is postponed , So as to avoid the above problems .

however , Since the watchdog exists as a separate thread , Impact on performance , If it is not a special resource that is highly competitive and the processing time is not fixed , It is not recommended to enable redisson The watchdog feature of .

5.2 Multiple locks are used together — interlocking

since redisson Through multiple redis The node implements RedLock, that , If a business needs to occupy several resources at the same time , Can I use multiple locks in combination ？ The answer is yes .

be based on Redis Distributed RedissonMultiLock The object will be more than one RLock Object grouping , And treat them as a lock . Every RLock Objects may belong to different Redisson example .

In this complex situation , Above “ watchdog ” It is recommended that the feature must be enabled , Because the crash of any lock state may cause the continuous suspension of all other locks or the accidental preemption of resources .

Here is redisson An example of interlocking ：

public void multiLock(Integer expireTime,TimeUnit timeUnit,String ...lockKey){
    RLock [] rLocks = new RLock[lockKey.length];
    for(int i = 0,length = lockKey.length; i < length ;i ++){
      RLock lock = redissonClient.getLock(lockKey[i]);
      rLocks[i] = lock;
    }
    RedissonMultiLock multiLock = new RedissonMultiLock(rLocks);
    multiLock.lock(expireTime,timeUnit);
    logger.info("【Redisson lock】success to acquire multiLock for [ "+lockKey+" ],expire time:"+expireTime+timeUnit);
  }

Copy