[转]分布式锁-RedisLockRegistry源码分析

前言

官网的英文介绍大概如下：

Starting with version 4.0, the RedisLockRegistry is available. Certain components (for example aggregator and resequencer) use a lock obtained from a LockRegistry instance to ensure that only one thread is manipulating a group at a time. The DefaultLockRegistry performs this function within a single component; you can now configure an external lock registry on these components. When used with a shared MessageGroupStore, the RedisLockRegistry can be use to provide this functionality across multiple application instances, such that only one instance can manipulate the group at a time.

When a lock is released by a local thread, another local thread will generally be able to acquire the lock immediately. If a lock is released by a thread using a different registry instance, it can take up to 100ms to acquire the lock.

To avoid "hung" locks (when a server fails), the locks in this registry are expired after a default 60 seconds, but this can be configured on the registry. Locks are normally held for a much smaller time.

上述大概意思是RedisLockRegistry可以确保在分布式环境中，只有一个thread在执行，也就是实现了分布式锁，当一个本地线程释放了锁，其他本地现场会立即去抢占锁，如果锁被占用了，那么会进行重试机制，100毫秒进行重试一次。同时也避免了"hung" locks 当服务器fails的时候。同时也给锁设置了默认60秒的过期时间

如何获取锁

详细流程如上图所示，这里主要核心业务是这样，首先Lock是java.util.concurrent.locks中的锁，也就是本地锁。然后自己用RedisLock实现了Lock接口而已，但是实际上RedisLock也使用了本地锁。主要是通过redis锁＋本地锁双重锁的方式实现的一个比较好的锁。针对redis锁来说只要能获取到锁，那么就算是成功的。如果获取不到锁就等待100毫秒继续重试，如果获取到锁那么就采用本地锁锁住本地的线程。通过两种方式很好的去实现了一个完善的分布式锁机制。

下面代码主要是获取锁的一个流程，先从本地锁里面获取，如果获取到了那么和redis里面存放的RedisLock锁做对比，判断是否是同一个对象，如果不是那么就删除本地锁然后重新创建一个锁返回

@Override
public Lock obtain(Object lockKey) {
    Assert.isInstanceOf(String.class, lockKey);

    //try to find the lock within hard references
    //从本地强引用里面获取锁,
    RedisLock lock = findLock(this.hardThreadLocks.get(), lockKey);

    /*
     * If the lock is locked, check that it matches what's in the store.
     * If it doesn't, the lock must have expired.
     */
    //这里主要判断了这个锁是否是锁住的,如果不是的那么该锁已经过期了
    //如果强引用里面有这个锁,并且lock.thread!=null，说明这个锁没有被占用
    if (lock != null && lock.thread != null) {
        //从redis获取锁,若如果redis锁为空或者跟当前强引用的锁不一致,可以确定两个问题
        //1.redis里面的锁和本地的锁不是一个了
        //2.redis里面没有锁
        RedisLock lockInStore = this.redisTemplate.boundValueOps(this.registryKey + ":" + lockKey).get();
        if (lockInStore == null || !lock.equals(lockInStore)) {
            //删除强引用里面锁
            getHardThreadLocks().remove(lock);
            lock = null;
        }
    }
    //如果锁==null
    if (lock == null) {
        //try to find the lock within weak references
        //尝试线从弱引用里面去找锁
        lock = findLock(this.weakThreadLocks.get(), lockKey);
        //如果弱引用锁==null 那么新建一个锁
        if (lock == null) {
            lock = new RedisLock((String) lockKey);
            //判断是否用弱引用,如果用那么就加入到弱引用里面
            if (this.useWeakReferences) {
                getWeakThreadLocks().add(lock);
            }
        }
    }

    return lock;
}

上面获取到的是RedisLock，RedisLock是实现java原生Lock接口，并重写了lock()方法。首先从localRegistry中获取到锁，这里的锁是java开发包里面的ReentrantLock。首先把本地先锁住，然后再去远程obtainLock。每次sleep() 100毫秒直到获取到远程锁为止，代码如下所示：

@Override
public void lock() {
    //这里采用java开发包里面的ReentrantLock 进行多线程的加锁,单机多线程的情况下解决并发的问题
    Lock localLock = RedisLockRegistry.this.localRegistry.obtain(this.lockKey);
    localLock.lock();
    while (true) {
        try {
            while (!this.obtainLock()) {
                Thread.sleep(100); //NOSONAR
            }
            break;
        }
        catch (InterruptedException e) {
                /*
                 * This method must be uninterruptible so catch and ignore
                 * interrupts and only break out of the while loop when
                 * we get the lock.
                 */
        }
        catch (Exception e) {
            localLock.unlock();
            rethrowAsLockException(e);
        }
    }
}

核心远程锁还是在RedisLock中，这里采用了redis事务＋watch的方式，watch和事务都是redis里面自带的。使用watch时候如果key的值发生了任何变化。那么exec()将不会执行，那么如下代码返回的success就是false。从而来实现redis锁的功能

private boolean obtainLock() {
    //判断创建这个类的线程和当前是否是一个,如果是就直接获取锁
    Thread currentThread = Thread.currentThread();
    if (currentThread.equals(this.thread)) {
        this.reLock++;
        return true;
    }
    //把当前锁存到集合种
    toHardThreadStorage(this);

    /*
     * Set these now so they will be persisted if successful.
     */
    this.lockedAt = System.currentTimeMillis();
    this.threadName = currentThread.getName();

    Boolean success = false;
    try {
        success = RedisLockRegistry.this.redisTemplate.execute(new SessionCallback<Boolean>() {

            @SuppressWarnings({"unchecked", "rawtypes"})
            @Override
            public Boolean execute(RedisOperations ops) throws DataAccessException {
                String key = constructLockKey();
                //监控key如果该key被改变了 那么该事务是不能被实现的会进行回滚
                ops.watch(key); //monitor key
                //如果key存在了就停止监控，如果key已经存在了 那么肯定是被别人占用了
                if (ops.opsForValue().get(key) != null) {
                    ops.unwatch(); //key already exists, stop monitoring
                    return false;
                }

                ops.multi(); //transaction start
                //设置一个值并加上过期时间 m默认是一分钟左右的时间
                //set the value and expire
                //把锁放入到redis中
                ops.opsForValue()
                        .set(key, RedisLock.this, RedisLockRegistry.this.expireAfter, TimeUnit.MILLISECONDS);

                //exec will contain all operations result or null - if execution has been aborted due to 'watch'
                return ops.exec() != null;
            }

        });

    }
    finally {
      //如果不成功那么把当前过期时间和锁的名字设置成null
        if (!success) {
            this.lockedAt = 0;
            this.threadName = null;
            toWeakThreadStorage(this);
        }
        else {
        //如果成功把当前锁的thread名称设置成currentThread
            this.thread = currentThread;
            if (logger.isDebugEnabled()) {
                logger.debug("New lock; " + this.toString());
            }
        }

    }

    return success;
}

上面是整个加锁的流程,基本流程比较简单，看完加锁应该自己都能解锁，无非就是去除redis锁和本地的锁而已。

@Override
public void unlock() {
    //判断当前运行的线程和锁的线程做对比，如果两个线程不一样那么抛出异常
    if (!Thread.currentThread().equals(this.thread)) {
        if (this.thread == null) {
            throw new IllegalStateException("Lock is not locked; " + this.toString());
        }
        throw new IllegalStateException("Lock is owned by " + this.thread.getName() + "; " + this.toString());
    }

    try {
       //如果reLock－－小于＝0的话就删除redis里面的锁
        if (this.reLock-- <= 0) {
            try {
                this.assertLockInRedisIsUnchanged();
                RedisLockRegistry.this.redisTemplate.delete(constructLockKey());
                if (logger.isDebugEnabled()) {
                    logger.debug("Released lock; " + this.toString());
                }
            }
            finally {
                this.thread = null;
                this.reLock = 0;
                toWeakThreadStorage(this);
            }
        }
    }
    finally {
    //拿到本地锁，进行解锁
        Lock localLock = RedisLockRegistry.this.localRegistry.obtain(this.lockKey);
        localLock.unlock();
    }
}

tryLock在原有的加锁上面增加了一个超时机制，主要是先通过本地的超时机制

@Override
public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
    //拿到本地锁
    Lock localLock = RedisLockRegistry.this.localRegistry.obtain(this.lockKey);
    //先本地锁进行tryLock
    if (!localLock.tryLock(time, unit)) {
        return false;
    }
    try {
        long expire = System.currentTimeMillis() + TimeUnit.MILLISECONDS.convert(time, unit);
        boolean acquired;
        //这里添加了超时机制，跟之前的无限等待做了一个区分
        while (!(acquired = obtainLock()) && System.currentTimeMillis() < expire) { //NOSONAR
            Thread.sleep(100); //NOSONAR
        }
         //超时后没有获取到锁，那么就把本地锁进行解锁
        if (!acquired) {
            localLock.unlock();
        }
        return acquired;
    }
    catch (Exception e) {
        localLock.unlock();
        rethrowAsLockException(e);
    }
    return false;
}