canal源码之BooleanMutex（基于AQS中共享锁实现）

在看canal源码时发现一个有趣的锁实现--BooleanMutex

这个锁在canal里面多处用到，相当于一个开关，比如系统初始化/授权控制，没权限时阻塞等待，有权限时所有线程都可以快速通过

先看它的核心基于AQS的锁实现：

private final class Sync extends AbstractQueuedSynchronizer {

        private static final long serialVersionUID = 2559471934544126329L;
        /** State value representing that TRUE */
        private static final int  TRUE             = 1;
        /** State value representing that FALSE */
        private static final int  FALSE            = 2;

        private boolean isTrue(int state) {
            return (state & TRUE) != 0;
        }
        /**
         * 实现AQS的接口，获取共享锁的判断
         */
        protected int tryAcquireShared(int state) {
            // 如果为true，直接允许获取锁对象
            // 如果为false，进入阻塞队列，等待被唤醒
            return isTrue(getState()) ? 1 : -1;
        }

        /**
         * 实现AQS的接口，释放共享锁的判断
         */
        protected boolean tryReleaseShared(int ignore) {
            // 始终返回true，代表可以release
            return true;
        }

        boolean innerState() {
            return isTrue(getState());
        }

        void innerGet() throws InterruptedException {
            acquireSharedInterruptibly(0);
        }

        void innerGet(long nanosTimeout) throws InterruptedException, TimeoutException {
            if (!tryAcquireSharedNanos(0, nanosTimeout)) throw new TimeoutException();
        }

        void innerSetTrue() {
            for (;;) {
                int s = getState();
                if (s == TRUE) {
                    return; // 直接退出
                }
                if (compareAndSetState(s, TRUE)) {// cas更新状态，避免并发更新true操作
                    releaseShared(0);// 释放一下锁对象，唤醒一下阻塞的Thread
                    return;
                }
            }
        }

        void innerSetFalse() {
            for (;;) {
                int s = getState();
                if (s == FALSE) {
                    return; // 直接退出
                }
                if (compareAndSetState(s, FALSE)) {// cas更新状态，避免并发更新false操作
                    return;
                }
            }
        }

    }

它重写了AQS中共享锁的判断可持有方法tryAcquireShared和判断可释放锁的方法tryReleaseShared

也就是说，它是重写AQS中共享锁的方法来实现的，有意思的是它不像普通AQS实现的共享锁，比如Semaphore这种有许可证个数，也就是同时能被几个线程持有是固定的，而它理论上只要打开了开关就允许任意线程通过

下面看下它是怎么实现的：

首先它定义了两个int类型属性：

/** State value representing that TRUE */
private static final int  TRUE             = 1;
/** State value representing that FALSE */
private static final int  FALSE            = 2;

这两个属性代表了AQS中state的值，也就是说这把锁中的state值始终为1或者2，看下下面这两个方法

　　　　void innerSetTrue() {
            for (;;) {
                int s = getState();
                if (s == TRUE) {
                    return; // 直接退出
                }
                if (compareAndSetState(s, TRUE)) {// cas更新状态，避免并发更新true操作
                    releaseShared(0);// 释放一下锁对象，唤醒一下阻塞的Thread
                    return;
                }
            }
        }

        void innerSetFalse() {
            for (;;) {
                int s = getState();
                if (s == FALSE) {
                    return; // 直接退出
                }
                if (compareAndSetState(s, FALSE)) {// cas更新状态，避免并发更新false操作
                    return;
                }
            }
        }

显而易见，这两个方法都自旋的CAS改变state的值，那这两个方法在哪里调用呢？

　　public void set(Boolean mutex) {
        if (mutex) {
            sync.innerSetTrue();
        } else {
            sync.innerSetFalse();
        }
    }

这个方法封装了改变state值的方法，其实它就相当于我们常用锁的加锁和释放锁方法，原因在于它获取共享锁的判断：

protected int tryAcquireShared(int state) {
    return isTrue(getState()) ? 1 : -1;
}　　　
private boolean isTrue(int state) {
    return (state & TRUE) != 0;
}

由于state值始终为1或0，当state值为0时isTrue返回false，tryAcquireShared返回-1，AQS在共享锁的获取锁判断中如果tryAcquireShared<0代表共享锁许可证已经颁发完，后续申请锁的线程需要进入FIFO队列等待

相反如果state值为1，tryAcquireShared>0就直接获取锁对象

所以，当set(false)的时候，自旋的CAS把state值改成0，线程需要等待，相反set(true)就能获取锁成功