Redisson 源码初探（八） RedLock

今天药忘吃喽~ 2022-11-03 05:45 125阅读 0赞

本篇主要讲解Redisson中得RedLock实现，但是很多知识因为和前面一样，就直接省略了

RedLock 原理理一下：

（1）获取当前时间戳，单位是毫秒

（2）和RedissonMultiLock一样，一次轮询尝试去每个机器上创建锁，需要加一个超时时间，如果超过一定时间就表示获取锁失败

（3）尝试在大多数节点上建立一个锁，如果3个节点就要求创建 n/2 + 1 = 2个节点上创建锁

（4）客户端计算建立锁的时间，如果在规定时间内，建立锁成功，就代表加锁成功

（5）如果建立锁失败，那么就会依次的删除锁

（6）只要别人创建了锁，那么你就得不停得轮询去尝试获取锁

public static void main(String[] args) throws Exception {
        	//构建一个配置信息对象
            Config config = new Config();
            config.useClusterServers()
                    //定时扫描连接信息 默认1000ms
                    .setScanInterval(2000)
                    .addNodeAddress("redis://127.0.0.1:7001");
    		//因为Redisson 是基于redis封装的一套便于复杂操作的框架
    		//所以这里构建对象肯定是创建一些与redis的连接
            RedissonClient redisson = Redisson.create(config);
    
            RLock lock1 = redisson.getLock("lock1");
            RLock lock2 = redisson.getLock("lock2");
            RLock lock3 = redisson.getLock("lock3");
            RedissonRedLock redLock = new RedissonRedLock(lock1,lock2,lock3);
    
            redLock.lock();
            //释放锁
            redLock.unlock();
        }

但是这个RedLock的源码相当的简单，为什么？我们学习了RedissonMultiLock的源码，其实你们想想RedLock的逻辑，其实是不是和RedissonMultiLock极其的相似，

对的，没错，RedLock 就是RedissonMultiLock 的一个子类，里面仅仅覆盖了几个方法

public class RedissonRedLock extends RedissonMultiLock {
    
        /**
         * Creates instance with multiple {@link RLock} objects.
         * Each RLock object could be created by own Redisson instance.
         *
         * @param locks - array of locks
         */
        public RedissonRedLock(RLock... locks) {
            super(locks);
        }
           //允许失败的个数
        @Override
        protected int failedLocksLimit() {
            return locks.size() - minLocksAmount(locks);
        }
        //最少要获取几个锁
         //如果size = 3，计算出来=2
        protected int minLocksAmount(final List<RLock> locks) {
            return locks.size()/2 + 1;
        }
        //计算等待时间，其实是计算出一个获取锁的超时时间
        @Override
        protected long calcLockWaitTime(long remainTime) {
            return Math.max(remainTime / locks.size(), 1);
        }
        
        @Override
        public void unlock() {
            unlockInner(locks);
        }
    
    }

public boolean tryLock(long waitTime, long leaseTime, TimeUnit unit) throws InterruptedException {
    //        try {
    //            return tryLockAsync(waitTime, leaseTime, unit).get();
    //        } catch (ExecutionException e) {
    //            throw new IllegalStateException(e);
    //        }
            long newLeaseTime = -1;
            if (leaseTime != -1) {
                newLeaseTime = unit.toMillis(waitTime)*2;
            }
            
            long time = System.currentTimeMillis();
            long remainTime = -1;
            if (waitTime != -1) {
                remainTime = unit.toMillis(waitTime);
            }
            //lockWitTime = 1500ms
            long lockWaitTime = calcLockWaitTime(remainTime);
            //以前MultiLock 是默认0，但是对于RedLock n- (n/2+1) 假设N=3.计算出来就是1
            int failedLocksLimit = failedLocksLimit();
            List<RLock> acquiredLocks = new ArrayList<RLock>(locks.size());
            for (ListIterator<RLock> iterator = locks.listIterator(); iterator.hasNext();) {
                RLock lock = iterator.next();
                boolean lockAcquired;
                try {
                    if (waitTime == -1 && leaseTime == -1) {
                        lockAcquired = lock.tryLock();
                    } else {
                        long awaitTime = Math.min(lockWaitTime, remainTime);
                        //获取每个小锁 超时时间是1500ms
                        lockAcquired = lock.tryLock(awaitTime, newLeaseTime, TimeUnit.MILLISECONDS);
                    }
                } catch (Exception e) {
                    lockAcquired = false;
                }
                
                if (lockAcquired) {
                    acquiredLocks.add(lock);
                } else {
                    //加锁失败会走到这里，这里是什么逻辑？
                    //之前multiLock 任何一个小锁加锁失败，都会退出循环，就是代表获取锁失败，
                    //但是注意外面的死循环，会再次进来尝试获取锁
                    //那么现在如果是RedLock 会是什么逻辑？
                    //那么如果是 3-2 = 1 == 1
                    //其实再RedLock 中也代表加锁成功你们想想
                    if (locks.size() - acquiredLocks.size() == failedLocksLimit()) {
                        break;
                    }
    
                    if (failedLocksLimit == 0) {
                        unlockInner(acquiredLocks);
                        if (waitTime == -1 && leaseTime == -1) {
                            return false;
                        }
                        failedLocksLimit = failedLocksLimit();
                        acquiredLocks.clear();
                        // reset iterator
                        //复位迭代器
                        while (iterator.hasPrevious()) {
                            iterator.previous();
                        }
                    } else {
                        //将加锁失败限制-1，就是代表你还剩余几次允许失败的次数
                        failedLocksLimit--;
                    }
                }
                
                if (remainTime != -1) {
                    remainTime -= (System.currentTimeMillis() - time);
                    time = System.currentTimeMillis();
                    if (remainTime <= 0) {
                        unlockInner(acquiredLocks);
                        return false;
                    }
                }
            }
    
            if (leaseTime != -1) {
                List<RFuture<Boolean>> futures = new ArrayList<RFuture<Boolean>>(acquiredLocks.size());
                for (RLock rLock : acquiredLocks) {
                    RFuture<Boolean> future = rLock.expireAsync(unit.toMillis(leaseTime), TimeUnit.MILLISECONDS);
                    futures.add(future);
                }
                
                for (RFuture<Boolean> rFuture : futures) {
                    rFuture.syncUninterruptibly();
                }
            }
            
            return true;
        }

那么释放锁呢，其实也就是依次得去调用底层RedissonLock得释放锁得API而已