Redismission source code analysis

Redisson There are two ways to lock ,tryLock and lock, The difference in use is tryLock You can set the expiration time of the lock leaseTime And waiting time waitTime, The logic of core processing is almost the same

    public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
        long time = unit.toMillis(waitTime);
        long current = System.currentTimeMillis();
        long threadId = Thread.currentThread().getId();

        //  Attempt to acquire lock , If you don't get the lock , The remaining timeout of the lock is returned  
        Long ttl = tryAcquire(waitTime, leaseTime, unit, threadId);
        // lock acquired

        // ttl by null, It means we can get the lock , return true 
        if (ttl == null) {
            return true;
        }
        

        //  If waitTime It's over time , Just go back to false, Failed to apply for lock  
        time -= System.currentTimeMillis() - current;
        if (time <= 0) {
            acquireFailed(waitTime, unit, threadId);
            return false;
        }
        
        current = System.currentTimeMillis();

        /**
         Subscribe to lock release events , And pass  await  Method blocks waiting for the lock to be released , It effectively solves the problem of waste of resources in invalid lock application ：
     Based on the amount of information , When the lock is occupied by other resources , The current thread passes  Redis  Of  channel  Release event of subscription lock 
     Once the lock is released, a message will be sent to inform the waiting thread to compete .
        */
        RFuture<RedissonLockEntry> subscribeFuture = subscribe(threadId);
        if (!subscribeFuture.await(time, TimeUnit.MILLISECONDS)) {
            if (!subscribeFuture.cancel(false)) {
                subscribeFuture.onComplete((res, e) -> {
                    if (e == null) {
                        unsubscribe(subscribeFuture, threadId);
                    }
                });
            }
            acquireFailed(waitTime, unit, threadId);
            return false;
        }

        try {

            // If the time taken to acquire the lock exceeds the maximum waiting time , Locking failed 
            time -= System.currentTimeMillis() - current;
            if (time <= 0) {
                acquireFailed(waitTime, unit, threadId);
                return false;
            }

            // Cycle to acquire the lock within the maximum waiting time 
            while (true) {
                long currentTime = System.currentTimeMillis();
                ttl = tryAcquire(waitTime, leaseTime, unit, threadId);
                // lock acquired
                if (ttl == null) {
                    return true;
                }

                time -= System.currentTimeMillis() - currentTime;
                if (time <= 0) {
                    acquireFailed(waitTime, unit, threadId);
                    return false;
                }

                // waiting for message
                currentTime = System.currentTimeMillis();

                // waiting for message, Wait for unlock message 
                if (ttl >= 0 && ttl < time) {
                    subscribeFuture.getNow().getLatch().tryAcquire(ttl, TimeUnit.MILLISECONDS);
                } else {
                    subscribeFuture.getNow().getLatch().tryAcquire(time, TimeUnit.MILLISECONDS);
                }

                time -= System.currentTimeMillis() - currentTime;
                if (time <= 0) {
                    acquireFailed(waitTime, unit, threadId);
                    return false;
                }
            }
        } finally {
            // Unsubscribe from messages 
            unsubscribe(subscribeFuture, threadId);
        }
//        return get(tryLockAsync(waitTime, leaseTime, unit));
    }

Redission Principle of distributed lock _ Zhizhi blog -CSDN Blog _redission Principle of implementing distributed lock Lock in the principle source code lua Code 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 (redis.call('hexists', KEYS[1], ARGV[2]) == 1) thenhttps://blog.csdn.net/weixin_35973945/article/details/124151830

 

Here's the thing to watch out for ,RedissonLock It's also not solved When the node hangs up , There is a risk of losing locks . And the reality is that there are some scenes that can't be tolerated , therefore Redisson Provides the implementation of redlock Algorithm RedissonRedLock,RedissonRedLock It really solves the problem of single point failure , The price is extra for RedissonRedLock build Redis Environmental Science .

therefore , If the business scenario can tolerate this small probability of error , It is recommended to use RedissonLock, If you can't stand , It is recommended to use RedissonRedLock.