AbstractQueuedSynchronizer初始应用之ReentrantLock

        前面介绍的是排他申请锁的情况，也就是synchronized语法支持的内容。但是业务中会有更加复杂的场景，通过对tryAcquire、tryRelease的覆写以及state属性的使用，我们可以达到控制并发的目的，满足具体的场景需求。但是许多场景都是有共性的，并且直接使用这些底层的方法去实现并发，一来代码复杂，二来容易出错，所以有必要针对这些场景封装出通用的并发组件，比如ReetrantLock。

        AbstractQueuedSynchronizer是一个抽象类，要具体使用需要对它进行继承，一般的实现比如ReentrantLock都是以内部类的形式实现一个AbstractQueuedSynchronizer子类，在外边做相应封装。
ReentrantLock中对acquire和release的实现如下：

  /**
         * Performs non-fair tryLock.  tryAcquire is implemented in
         * subclasses, but both need nonfair try for trylock method.
         */
        final boolean nonfairTryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {//如果锁尚未被占用
                if (compareAndSetState(0, acquires)) {//cas获得锁
                    setExclusiveOwnerThread(current);//设置锁的占有线程为当前线程
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;//锁重入次数控制
                if (nextc < 0) // overflow
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }

        protected final boolean tryRelease(int releases) {
            int c = getState() - releases;
            if (Thread.currentThread() != getExclusiveOwnerThread())
                throw new IllegalMonitorStateException();
            boolean free = false;
            if (c == 0) {//表示可以将锁供给其他线程用
                free = true;
                setExclusiveOwnerThread(null);
            }
            setState(c);
            return free;
        }

非公平锁的实现：

/**
     * Sync object for non-fair locks
     */
    static final class NonfairSync extends Sync {
        private static final long serialVersionUID = 7316153563782823691L;

        /**
         * Performs lock.  Try immediate barge, backing up to normal
         * acquire on failure.
         */
        final void lock() {
            if (compareAndSetState(0, 1))//直接去抢占，而没有去管是否前面有等待的节点
                setExclusiveOwnerThread(Thread.currentThread());
            else
                acquire(1);
        }

        protected final boolean tryAcquire(int acquires) {
            return nonfairTryAcquire(acquires);
        }
    }

公平锁的实现与非公平锁相差很小：

 /**
     * Sync object for fair locks
     */
    static final class FairSync extends Sync {
        private static final long serialVersionUID = -3000897897090466540L;

        final void lock() {
            acquire(1);
        }

        /**
         * Fair version of tryAcquire.  Don't grant access unless
         * recursive call or no waiters or is first.
         */
        protected final boolean tryAcquire(int acquires) {
            final Thread current = Thread.currentThread();
            int c = getState();
            if (c == 0) {
                //多了一层前面没有等待的节点的判断
                // 如果有等待中的节点，并且本节点非head的下一个节点，则不会去抢占锁
                if (!hasQueuedPredecessors() &&
                        compareAndSetState(0, acquires)) {
                    setExclusiveOwnerThread(current);
                    return true;
                }
            }
            else if (current == getExclusiveOwnerThread()) {
                int nextc = c + acquires;
                if (nextc < 0)
                    throw new Error("Maximum lock count exceeded");
                setState(nextc);
                return true;
            }
            return false;
        }
    }