Have you got all the distributed locks we used in those years

Features of distributed locks

• Mutual exclusivity ： Like our local locks, mutex is the most basic , But distributed locks need to guarantee the mutual exclusion of different threads in different nodes .
• Reentrancy ： If the same thread on the same node acquires the lock, it can acquire the lock again .
• Lock timeout ： Support lock timeout as well as local lock , Prevent deadlock .

zookeeper Implement distributed locks

• zookeeper Distributed locks are based on Temporary order node To achieve
• adopt session To prevent lock timeout
• zookeeper The temporary node of is automatically deleted after the client is disconnected , It can solve the deadlock problem
• When the sequence number of its own node is not the minimum , Through monitoring mechanism , Wait until the node number is the minimum , Blocking lock can be realized
• In creating the node is , The client writes its own information to the node , Get all , Judge by node information , Lock reentry can be realized

Redis Implement distributed locks

be based on SET NX EX Realization , Stand-alone version

Here use Redis set key It's a NX Parameters can be guaranteed in this key Write succeeded in the absence of . And add EX Parameter can make this key Automatically delete after timeout .

• Lock

private static final String SET_IF_NOT_EXIST = "NX";
private static final String SET_WITH_EXPIRE_TIME = "PX";
public  boolean tryLock(String key, String request) {
    
    String result = this.jedis.set(LOCK_PREFIX + key, request, SET_IF_NOT_EXIST, SET_WITH_EXPIRE_TIME, 10 * TIME);
    if (LOCK_MSG.equals(result)){
    
        return true ;
    }else {
    
        return false ;
    }
}

• Unlock

Unlocking is also easy , In fact, this is key Delete it and everything will be fine , For example, use del key command .

public  boolean unlock(String key,String request){
    
    //lua script
    String script = "if redis.call('get', KEYS[1]) == ARGV[1] then return redis.call('del', KEYS[1]) else return 0 end";
    Object result = null ;
    if (jedis instanceof Jedis){
    
        result = ((Jedis)this.jedis).eval(script, Collections.singletonList(LOCK_PREFIX + key), Collections.singletonList(request));
    }else if (jedis instanceof JedisCluster){
    
        result = ((JedisCluster)this.jedis).eval(script, Collections.singletonList(LOCK_PREFIX + key), Collections.singletonList(request));
    }else {
    
        //throw new RuntimeException("instance is error") ;
        return false ;
    }
    if (UNLOCK_MSG.equals(result)){
    
        return true ;
    }else {
    
        return false ;
    }
}

be based on Redisson Realization , High availability version

Reference address ：https://codechina.csdn.net/mirrors/redisson/redisson?utm_source=csdn_github_accelerator

// 1.  The configuration file 
Config config = new Config();
config.useSingleServer()
        .setAddress("redis://127.0.0.1:6379")
        .setPassword(RedisConfig.PASSWORD)
        .setDatabase(0);
//2.  structure RedissonClient
RedissonClient redissonClient = Redisson.create(config);

//3.  Set the lock resource name 
RLock lock = redissonClient.getLock("redlock");
lock.lock();
try {
    
    System.out.println(" Lock acquired successfully , Implement business logic ");
    Thread.sleep(10000);
} catch (InterruptedException e) {
    
    e.printStackTrace();
} finally {
    
    lock.unlock();
}

Redis Distributed lock VS zookeeper Distributed lock

• zookeeper Reliability than redis Too much , It's just a little inefficient , If the amount of concurrency is not particularly large , The pursuit of reliability , The preferred zookeeper. For efficiency , Preferred redis Realization .
• zookeeper Distributed lock performance may not Redis The distributed lock is so high . Because every time you create a lock and release a lock , All need to be created dynamically 、 Destroy the instantaneous node to realize the lock function .zookeeper You can only create and delete nodes through Leader Server to execute , Then synchronize the data to all Follower On the machine .
• zookeeper Atomicity of is based on sequence=false Ensure node uniqueness ,redis Atomicity of is based on lua Script
• redis There may be data loss , because redis After the memory operation is successful, it returns directly success, At this time, data loss can be caused without flushing the disk, resulting in lock failure