public abstract class AbstractOwnableSynchronizer
            implements java.io.Serializable {

        private static final long serialVersionUID = 3737899427754241961L;

        protected AbstractOwnableSynchronizer() {
        }

        private transient Thread exclusiveOwnerThread;

        protected final void setExclusiveOwnerThread(Thread thread) {
            exclusiveOwnerThread = thread;
        }

        protected final Thread getExclusiveOwnerThread() {
            return exclusiveOwnerThread;
        }
    }

    private transient volatile Node head;

    private transient volatile Node tail;

    private volatile int state;

        volatile int waitStatus;

        volatile Node prev;

        volatile Node next;

        volatile Thread thread;

        Node nextWaiter;

        static final Node SHARED = new Node();

        static final Node EXCLUSIVE = null;

        static final int CANCELLED = 1;

        static final int SIGNAL = -1;

        static final int CONDITION = -2;

        static final int PROPAGATE = -3;

Node() {    // Used to establish initial head or SHARED marker
}

    Node(Thread thread, Node mode) {     // Used by addWaiter
            this.nextWaiter = mode;
            this.thread = thread;
        }

        Node(Thread thread, int waitStatus) { // Used by Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
        }

    public final void acquire(int arg) {
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

    private Node addWaiter(Node mode) {
        Node node = new Node(Thread.currentThread(), mode);
        // Try the fast path of enq; backup to full enq on failure
        Node pred = tail;  //记录旧尾节点
        if (pred != null) {
            //pred不为null表明队列中至少有一个节点
            node.prev = pred;//新添加的节点node作为队列最新的尾节点，那么node的前驱节点则是以前的旧尾节点
            if (compareAndSetTail(pred, node)) {
                /**
                 * cas设置新的尾节点成功，将从方法返回
                 * 旧尾节点的后继节点则是新添加的node节点
                 */
                pred.next = node;
                return node;
            }
        }
        //cas设置新的尾节点失败，进入enq方法，通过CAS进行死循环般地设置新的尾节点
        enq(node);
        return node;
    }
    private Node enq(final Node node) {
        for (;;) {
            Node t = tail;//尾节点为null，表明队列中一个节点都没有，是一个空队列
            if (t == null) { // Must initialize
                if (compareAndSetHead(new Node()))//CAS设置地设置头节点
                    tail = head;//此时队列中只有一个节点，头尾节点是同一个节点
            } else {
                node.prev = t;//新添加的节点node作为队列最新的尾节点，那么node的前驱节点则是以前的旧尾节点
                if (compareAndSetTail(t, node)) {//CAS更新失败则继续循环CAS设置尾节点
                    /**
                     * cas设置新的尾节点成功，将从方法返回
                     * 旧尾节点的后继节点则是新添加的node节点
                     */
                    t.next = node;
                    return t;
                }
            }
        }
    }

    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;//获取同步状态的标志flag
        try {
            boolean interrupted = false;//线程中断标志的flag
            for (;;) {
                final Node p = node.predecessor(); //p为node的前驱节点
                if (p == head && tryAcquire(arg)) {//p的前驱节点是头节点，且尝试获取同步状成功
                    /**
                     * setHead的方法体代码
                     *  head = node;
                     *  node.thread = null;
                     *  node.prev = null;
                     */
                    setHead(node);//将node设为新的头节点
                    p.next = null; //旧的头节点不会再使用了，将其相关属性解引用，便于垃圾回收
                    failed = false;
                    return interrupted;
                }
                /**
                 * shouldParkAfterFailedAcquire()方法用来检测在同步状态获取失败的情况下，线程是否需要阻塞.
                 * 如果shouldParkAfterFailedAcquire返回true,将会调用parkAndCheckInterrupt（）进行线程阻塞，并进行中断状态检测，
                 * parkAndCheckInterrupt（）返回是否中断的状态
                 */
                if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed) //如果同步状态获取失败则取消同步状态的获取
                cancelAcquire(node);
        }
    }

    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;
        if (ws == Node.SIGNAL)
            /*
             * This node has already set status asking a release
             * to signal it, so it can safely park.
             * 前驱节点刚好是SIGNAL,前驱节点就马上可能获取到同步状态了，
             * 自己可以去休眠睡一会了。如果前驱状态不是SIGNAL，node还要参加同步状态的争夺，它还不能睡觉。
             */
            return true;
        if (ws > 0) { //ws==CANCELLED
            /*
             * Predecessor was cancelled. Skip over predecessors and
             * indicate retry.
             * 前驱节点被取消了，必须向前遍历找到一个有效状态的节点作为node的前驱节点。
             * 中间这些无效的节点也从同步队列中移除掉了。
             */
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);
            pred.next = node;
        } else {
            /*
             * waitStatus must be 0 or PROPAGATE.  Indicate that we
             * need a signal, but don't park yet.  Caller will need to
             * retry to make sure it cannot acquire before parking.
             * 如果前驱正常，那就把前驱的状态设置成SIGNAL。CAS可能失败，pred可能刚释放锁
             */
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;

private final boolean parkAndCheckInterrupt() {
    LockSupport.park(this);
    return Thread.interrupted();
}

    private void cancelAcquire(Node node) {
        // Ignore if node doesn't exist
        if (node == null)
            return;
        node.thread = null;
        // Skip cancelled predecessors
        //pred表示在队列中node前面的最近的有效节点
        Node pred = node.prev;
        ////向前遍历找到离node最近的有效节点
        while (pred.waitStatus > 0)
            node.prev = pred = pred.prev;
 
        //保存pred的原始后继节点，在CAS更新pre的后继节点将会用到predNext
        Node predNext = pred.next; //
 
        // Can use unconditional write instead of CAS here.
        // After this atomic step, other Nodes can skip past us.
        // Before, we are free of interference from other threads.
        /*
         *无条件设置为取消状态，在此后其他线程见到此节点的状态，将会路过此节点。
         * 在此之前其他线程不受影响
         */
        node.waitStatus = Node.CANCELLED;
 
        // If we are the tail, remove ourselves.
        //如果是node尾节点，则尝试将与node最近的有效节点pred设置为新的尾节点
        if (node == tail && compareAndSetTail(node, pred)) {
            /**
             * 上面的CAS成功，pred就是最新的尾节点，尾节点的后继节点为null
             * 因此CAS将pred的后继节点设为null,而之前的 “while (pred.waitStatus > 0)”循环已经将其前驱节点更新了。
             *
             */
            compareAndSetNext(pred, predNext, null);
        } else {
            // If successor needs signal, try to set pred's next-link
            // so it will get one. Otherwise wake it up to propagate.
            int ws;
            if (pred != head &&
                    ((ws = pred.waitStatus) == Node.SIGNAL ||
                            (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
                    pred.thread != null) {
                //当pred是中间节点，且（pred状态是SIGNAL或cas成功设为SIGNAL），
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);//将node的后继节点设pred的后继节点
            } else {
                //否则唤醒node的后继节点，其后继节点进行锁争夺
                unparkSuccessor(node);
            }
 
            node.next = node; // help GC
        }
    }

   public final void acquireInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (!tryAcquire(arg))
            doAcquireInterruptibly(arg);
    }

    private void doAcquireInterruptibly(int arg)
            throws InterruptedException {
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return;
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                /**
                 *与 acquireQueued(Node,int)相比，只有此处不同，acquireQueued方法在此处用布尔变量interrupted标记为true,
                 * 而本方法则直接抛出异常
                 */
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    public final boolean tryAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        return tryAcquire(arg) ||
            doAcquireNanos(arg, nanosTimeout);
    }

 private boolean doAcquireNanos(int arg, long nanosTimeout)
            throws InterruptedException {
        if (nanosTimeout <= 0L)//nanosTimeout为负数,超时时间无效，直接返回false
            return false;
        final long deadline = System.nanoTime() + nanosTimeout;
        final Node node = addWaiter(Node.EXCLUSIVE);
        boolean failed = true;
        try {
            for (; ; ) {
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) {
                    setHead(node);
                    p.next = null; // help GC
                    failed = false;
                    return true;
                }
                nanosTimeout = deadline - System.nanoTime();
                if (nanosTimeout <= 0L)//超时间已到，方法返回false
                    return false;
                if (shouldParkAfterFailedAcquire(p, node) &&
                        nanosTimeout > spinForTimeoutThreshold)
                    /*
                     *spinForTimeoutThreshold是常数为1000,当超时时间剩余不足1000纳秒时,
                     * 直接进入死循环的快速自旋，而不使用LockSupport.parkNanos方法进行线程阻塞。
                     * 主要原因是：在极短时间条件下，LockSupport.parkNanos无法做精细时间控制
                     */
                    LockSupport.parkNanos(this, nanosTimeout);
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    public final boolean release(int arg) {
        if (tryRelease(arg)) {//尝试释放同步状态(同步组件需要重写tryRelease)
            Node h = head;
            if (h != null && h.waitStatus != 0)//waitStatus为零，是初始状态，获得同步状态节点的waitStatus不能为零。
                unparkSuccessor(h);//唤醒后继节点
            return true;
        }
        return false;
    }

    private void unparkSuccessor(Node node) {

        int ws = node.waitStatus;
        /*
         *waitStatus若为负数，表示可能需要一个信号，这里尝试将它清空，设为初始值0。若是正数只能是CANCELLED,这个状态不能再改变
         */
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);
        /*
         * 一般是直接将后继节点直接唤醒，但后继节点可能为null也可能是CANCELLED状态（此状态不再变化，需要从同步队列中取消等待），
         * 因此在等待队列中从后向前遍历，找到离node最近的非CANCELLED后继节点
         */
        Node s = node.next;
        //waitStatus大于0，只能取Node.CANCELLED这个常量，常量值为1
        if (s == null || s.waitStatus > 0) {//表达式的含义是：node后继节点为null或CANCELLED状态
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0)//只要waitStatus不取值Node.CANCELLED，waitStatus就小于0
                    s = t;
        }
        if (s != null)
            LockSupport.unpark(s.thread);//底层调用Unsafe的unpark(Thread)方法，这是一个用C++实现的本地方法，将线程唤醒
    }

    public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
    }
    private void doAcquireShared(int arg) {
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);
                    if (r >= 0) {
                        /**
                         * 与acquireQueued(int)的获取区主要在此，
                         * 不仅要设置新的头节点，还要根据获取同步状成功后的返回值来设置后继节点的waitState传播状态
                         */
                        setHeadAndPropagate(node, r);
                        p.next = null; // help GC
                        if (interrupted)
                            selfInterrupt();
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                        parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head; // Record old head for check below
        setHead(node);
      ////如果还有剩余量，继续唤醒下一个邻居线程
        if (propagate > 0 || h == null || h.waitStatus < 0 ||
                (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;
            if (s == null || s.isShared())
                doReleaseShared();
        }
    }

    public final boolean releaseShared(int arg) {
        if (tryReleaseShared(arg)) {
            doReleaseShared();
            return true;
        }
        return false;
    }

    private void doReleaseShared() {
        for (;;) {
            Node h = head;
            if (h != null && h != tail) {
                int ws = h.waitStatus;
                if (ws == Node.SIGNAL) {//SIGNAL表示后继节点的线程处于等待状态，当前节点释放后，后继节点则可运行
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))//尝试将waitState重置为初始状态0
                        continue;            // CAS更新失败,将自旋调用compareAndSetWaitStatus更新为0
                    unparkSuccessor(h);//CAS成功将waitState设置为0，调用此方法来唤醒后继节点
                }
                //不需要信号SIGNAL，且waitState为0，则将尝试将waitState设置为Node.PROPAGATE（共享锁的特有状态）
                else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                //  CAS更新失败,将自旋调用compareAndSetWaitStatus更新为Node.PROPAGATE
            }
            // 共享锁可同时被多个线程获取，也可能被多个线程同时释放，当其他某些线程将头节点被改变了(h与head不等），此自旋的循环将继续进行下去
            if (h == head)
                break;
        }
    }