AbstractQueuedSynchronizer

/**自旋锁，CLH锁也是一种基于链表的可扩展、高性能、公平的自旋锁，申请线程只在本地变量上自旋，
 * 它不断轮询前驱的状态，如果发现前驱释放了锁就结束自旋。
 *
 * 提供了一个基于FIFO队列，可以用于构建锁或者其他相关同步装置的基础框架。
 *
 * 利用了一个int来表示状态，期望它能够成为实现大部分同步需求的基础。
 *
 * 该同步器即可以作为排他模式也可以作为共享模式，当它被定义为一个排他模式时，
 * 其他线程对其的获取就被阻止，而共享模式对于多个线程获取都可以成功。
 */

public abstract class AbstractQueuedSynchronizer
    extends AbstractOwnableSynchronizer
    implements java.io.Serializable {

    private static final long serialVersionUID = 7373984972572414691L;

    protected AbstractQueuedSynchronizer() { }

    //保存着线程引用和线程状态的容器，每个线程对同步器的访问，都可以看做是队列中的一个节点。
    static final class Node {

        //共享模式
        static final Node SHARED = new Node();

        //独占模式
        static final Node EXCLUSIVE = null;

        //表示当前的线程被取消
        static final int CANCELLED =  1;

        //表示当前节点的后继节点包含的线程需要运行，也就是unpark
        static final int SIGNAL    = -1;

        //表示当前节点在等待condition，也就是在condition队列中
        static final int CONDITION = -2;
        /**
         * waitStatus value to indicate the next acquireShared should
         * unconditionally propagate
         */
        //表示当前场景下后续的acquireShared能够得以执行
        static final int PROPAGATE = -3;

        // 结点状态
        volatile int waitStatus;

        //前驱结点
        volatile Node prev;

        //后继结点
        volatile Node next;

        //如队列的当前线程
        volatile Thread thread;

        //存储condition队列中的后继节点
        Node nextWaiter;

        // 结点是否在共享模式下等待
        final boolean isShared() {
            return nextWaiter == SHARED;
        }

        // 获取前驱结点，若前驱结点为空，抛出异常
        final Node predecessor() throws NullPointerException {
            Node p = prev;
            if (p == null)
                throw new NullPointerException();
            else
                return p;
        }

        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;
        }
    }

    //头结点
    private transient volatile Node head;

    //尾结点
    private transient volatile Node tail;

    //同步状态
    private volatile int state;

    protected final int getState() {
        return state;
    }

    protected final void setState(int newState) {
        state = newState;
    }
    //原子操作更新同步状态值
    protected final boolean compareAndSetState(int expect, int update) {
        // See below for intrinsics setup to support this
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }

    //自旋时间
    static final long spinForTimeoutThreshold = 1000L;

    private Node enq(final Node node) {
        for (;;) { //无限循环，确保结点能够成功入队列
            //保存尾结点
            Node t = tail;
            if (t == null) { //尾结点为空，初始化
                if (compareAndSetHead(new Node()))
                    tail = head;
            } else { //尾结点非空，已经初始化
                node.prev = t;
                if (compareAndSetTail(t, node)) {//原子操作将尾结点更新设置为node
                    t.next = node;
                    return t;//返回尾结点
                }
            }
        }
    }

    //快速添加的方式往sync queue尾部添加结点
    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) {//尾结点非空，已经初始化
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {//原子操作将尾结点更新设置为node
                pred.next = node;
                return node;//返回新生成的结点
            }
        }
        enq(node);// 尾结点为空，或者是compareAndSetTail操作失败，则入队列
        return node;
    }

    private void setHead(Node node) {
        head = node;
        node.thread = null;
        node.prev = null;
    }

    //唤醒node后继结点的线程
    private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0)
            compareAndSetWaitStatus(node, ws, 0);//比较并且设置结点等待状态为0
        Node s = node.next;
        if (s == null || s.waitStatus > 0) {//后继结点为空或者其等待状态大于0，即为CANCELLED
            s = null;
            // 从尾结点开始从后往前开始遍历
            for (Node t = tail; t != null && t != node; t = t.prev)
                if (t.waitStatus <= 0) 找到等待状态小于等于0的结点，找到最前的状态小于等于0的结点
                    s = t;
        }
        if (s != null)//该结点不为空，释放线程许可
            LockSupport.unpark(s.thread);
    }

    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))//设置h.waitStatus = 0
                        continue;            // loop to recheck cases
                    unparkSuccessor(h);//唤醒后继结点
                }
                else if (ws == 0 &&
                         !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue;                // loop on failed CAS
            }
            if (h == head)                   // loop if head changed
                break;
        }
    }

    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();// 以共享模式进行释放
        }
    }

    //取消继续获取锁
    private void cancelAcquire(Node node) {
        if (node == null)
            return;
        node.thread = null;
        Node pred = node.prev;
        while (pred.waitStatus > 0)//找到node前驱结点中最近的一个不为CANCELLED状态的结点
            node.prev = pred = pred.prev;
        Node predNext = pred.next;
        node.waitStatus = Node.CANCELLED;

        // node结点为尾结点，则设置尾结点为pred结点
        if (node == tail && compareAndSetTail(node, pred)) {
            compareAndSetNext(pred, predNext, null);
        } else {//node结点不为尾结点，或者比较设置不成功
            // 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) {
                Node next = node.next;
                //后继结点不为空并且状态小于等于0
                if (next != null && next.waitStatus <= 0)
                    compareAndSetNext(pred, predNext, next);//比较并设置pred.next = next
            } else {
                unparkSuccessor(node);//uppark node后继结点
            }

            node.next = node; // help GC
        }
    }

    //获取锁失败后，检查并且更新结点状态
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        int ws = pred.waitStatus;//前驱结点的状态
        if (ws == Node.SIGNAL) //状态为SIGNAL = -1
            //可以进行park操作
            return true;
        if (ws > 0) { //状态为CANCELLED = 1
            do {
                node.prev = pred = pred.prev;
            } while (pred.waitStatus > 0);//找到pred结点前面最近的一个状态不为CANCELLED的结点
            pred.next = node;
        } else {
            //比较并设置前驱结点的状态为SIGNAL
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
        }
        return false;// 不能进行park操作
    }

    static void selfInterrupt() {
        Thread.currentThread().interrupt();
    }

    private final boolean parkAndCheckInterrupt() {
        LockSupport.park(this);//挂起线程
        return Thread.interrupted();//返回线程是否被中断
    }

    /**
    * ① 判断结点的前驱是否为head并且是否成功获取(资源)。
　　 * ② 若步骤①均满足，则设置结点为head，之后会判断是否finally模块，然后返回。
　　 * ③ 若步骤①不满足，则判断是否需要park当前线程，是否需要park当前线程的逻辑是判断结点的前驱结点的状态是否为SIGNAL，若是，则park当前结点，否则，不进行park操作。
　　 * ④ 若park了当前线程，之后某个线程对本线程unpark后，并且本线程也获得机会运行。那么，将会继续进行步骤①的判断。
    */
    //sync结点在独占且忽略中断模式下获取锁
    final boolean acquireQueued(final Node node, int arg) {
        boolean failed = true;
        try {
            boolean interrupted = false;//中断标志
            for (;;) {
                //获取node结点的前驱结点
                final Node p = node.predecessor();
                if (p == head && tryAcquire(arg)) { //前驱为头结点并且成功获得锁
                    setHead(node);//将当前结点设置为头节点
                    p.next = null; // help GC
                    failed = false;
                    return interrupted;
                }
                //只有当该节点的前驱结点的状态为SIGNAL时，才可以对该结点所封装的线程进行park操作
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())
                    interrupted = true;
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    private void doAcquireSharedInterruptibly(int arg)
        throws InterruptedException {
        //添加结点代队列
        final Node node = addWaiter(Node.SHARED);
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();//获取结点的前驱结点
                if (p == head) {//前驱结点为头结点
                    int r = tryAcquireShared(arg);// 试图在共享模式下获取对象状态
                    if (r >= 0) { // 获取成功
                        setHeadAndPropagate(node, r);// 设置头结点并进行繁殖
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) &&
                    parkAndCheckInterrupt())// 在获取失败后是否需要禁止线程并且进行中断检查
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    //以独占的方式获取锁，对中断不敏感
    public final void acquire(int arg) {
        //以独占的方式tryAcquire()尝试获取锁
        //如果获取不到，将当前线程构造成节点Node并加入sync队列
        if (!tryAcquire(arg) &&
            acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            selfInterrupt();
    }

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

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

    //独占模式释放锁
    public final boolean release(int arg) {
        if (tryRelease(arg)) {//释放成功
            Node h = head;
            //头结点不为空且状态不为0
            if (h != null && h.waitStatus != 0)
                unparkSuccessor(h);//唤醒头结点的后继结点
            return true;
        }
        return false;
    }

    public final void acquireShared(int arg) {
        if (tryAcquireShared(arg) < 0)
            doAcquireShared(arg);
    }

    public final void acquireSharedInterruptibly(int arg)
            throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)
            doAcquireSharedInterruptibly(arg);
    }

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

    final boolean isOnSyncQueue(Node node) {
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        if (node.next != null) // If has successor, it must be on queue
            return true;
        return findNodeFromTail(node);
    }


    final boolean transferForSignal(Node node) {
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;
        Node p = enq(node);
        int ws = p.waitStatus;
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))
            LockSupport.unpark(node.thread);
        return true;
    }

    final boolean transferAfterCancelledWait(Node node) {
        if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) {
            enq(node);
            return true;
        }
        while (!isOnSyncQueue(node))
            Thread.yield();
        return false;
    }

    final int fullyRelease(Node node) {
        boolean failed = true;
        try {
            int savedState = getState();
            if (release(savedState)) {
                failed = false;
                return savedState;
            } else {
                throw new IllegalMonitorStateException();
            }
        } finally {
            if (failed)
                node.waitStatus = Node.CANCELLED;
        }
    }

    public class ConditionObject implements Condition, java.io.Serializable {
        private static final long serialVersionUID = 1173984872572414699L;
        /** First node of condition queue. */
        //condition队列头结点
        private transient Node firstWaiter;
        /** Last node of condition queue. */
        //condition队列尾结点
        private transient Node lastWaiter;

        public ConditionObject() { }

        //添加新的waiter到wait队列
        private Node addConditionWaiter() {
            //保存尾结点
            Node t = lastWaiter;
            // If lastWaiter is cancelled, clean out.
            if (t != null && t.waitStatus != Node.CONDITION) {// 尾结点不为空，并且尾结点的状态不为CONDITION
                unlinkCancelledWaiters();//清除状态为不是CONDITION的结点
                t = lastWaiter;// 将最后一个结点重新赋值给t
            }
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)// 尾结点为空
                firstWaiter = node;//设置头结点为node
            else
                t.nextWaiter = node; //设置尾结点nextWaiter域为node结点
            lastWaiter = node;//尾结点指向node
            return node;
        }

        /**
         * Removes and transfers nodes until hit non-cancelled one or
         * null. Split out from signal in part to encourage compilers
         * to inline the case of no waiters.
         * @param first (non-null) the first node on condition queue
         */
        private void doSignal(Node first) {
            do {
                if ( (firstWaiter = first.nextWaiter) == null)//该结点的nextWaiter域为null，设置尾结点为null
                    lastWaiter = null;
                first.nextWaiter = null;
            } while (!transferForSignal(first) &&
                     (first = firstWaiter) != null);// 将结点从condition队列转移到sync队列失败并且condition队列中的头结点不为空，一直循环
        }

        /**
         * Removes and transfers all nodes.
         * @param first (non-null) the first node on condition queue
         */
        private void doSignalAll(Node first) {
            lastWaiter = firstWaiter = null;
            do {
                Node next = first.nextWaiter;
                first.nextWaiter = null;
                transferForSignal(first);// 将first结点从condition队列转移到sync队列
                first = next;
            } while (first != null);
        }

        //清除状态不是CONDITION的结点
        private void unlinkCancelledWaiters() {
            //保存condition队列头结点
            Node t = firstWaiter;
            Node trail = null;
            while (t != null) {
                Node next = t.nextWaiter;
                if (t.waitStatus != Node.CONDITION) {// t结点的状态不为CONDTION状态
                    t.nextWaiter = null;// 设置t节点的nextWaiter域为空
                    if (trail == null)
                        firstWaiter = next;// 重新设置condition队列的头结点
                    else
                        trail.nextWaiter = next;
                    if (next == null)
                        lastWaiter = trail;// 设置condition队列的尾结点
                }
                else // t结点的状态为CONDTION状态
                    trail = t; // 设置trail结点
                t = next;
            }
        }

        // 唤醒一个等待线程,如果所有的线程都在等待此条件，则选择其中一个唤醒。
        public final void signal() {
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

        // 唤醒所有等待线程。如果所有的线程都在等待此条件，则唤醒所有线程
        public final void signalAll() {
            if (!isHeldExclusively())//当前线程不是锁的拥有者，抛出异常
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignalAll(first);
        }

         // 等待，当前线程在接到信号之前一直处于等待状态
        public final void awaitUninterruptibly() {
            // 将当前线程添加到等待队列
            Node node = addConditionWaiter();
            //释放当前线程持有的锁
            int savedState = fullyRelease(node);
            boolean interrupted = false;
            //signal操作会将Node从Condition队列中拿出并且放入到sync等待队列中去，在不在AQS等待队列就看signal是否执行了
            //如果不在AQS等待队列中，就park当前线程，如果在，就退出循环
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);// 阻塞当前线程
                if (Thread.interrupted())// 当前线程被中断
                    interrupted = true;
            }
            // 自旋等待尝试再次获取锁，调用acquireQueued方法
            if (acquireQueued(node, savedState) || interrupted)
                selfInterrupt();
        }

        //等待，当前线程在接到信号或被中断之前一直处于等待状态
        public final void await() throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // clean up if cancelled
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
        }
    }


}