AQS4源码

@SuppressWarnings("restriction")
public abstract class AbstractQueuedSynchronizer1 extends AbstractOwnableSynchronizer1 implements java.io.Serializable {
    private static final long serialVersionUID = 7373984972572414691L;
    protected AbstractQueuedSynchronizer1() {}
    protected final int getState() {
        return state;
    }
    protected final void setState(int newState) {
        state = newState;
    }
    static final long spinForTimeoutThreshold = 1000L;

    //写成员变量时候用到cas，读的时候不用cas，有可能读到之后改变了，所以写的时候就会失败。
    //写成员变量都要CAS，除非是要强制修改，覆盖别人的修改。
    
    private Node enq(final Node node) {//修改尾节点失败
        for (;;) {
            Node t = tail;
            if (t == null) {//如果尾指针为null，则头指针也一定为null，表示等待队列未初始化，就CAS初始化队列。  
                if (compareAndSetHead(new Node()))//相当于加锁，因为不会重新获取头结点。
                    tail = head;//初始化头尾节点为空节点，
            } else {//如果尾指针非null，则队列已初始化，就CAS尝试在尾节点后插入新的节点node。
                node.prev = t;
                if (compareAndSetTail(t, node)) {//修改尾节点为新节点（成员变量变了，局部变量没变），失败了node.prev=t也无效。
                    t.next = node;//for的死循环，所以不相当于加锁，因为重新获取了尾节点，里面可以多线程都进来，但是不影响。
                    return t;
                }
            }
        }
    }

    //mode:Node.EXCLUSIVE独占, Node.SHARED共享的。
    private Node addWaiter(Node mode) {
        // 构造节点，mode有两种：EXCLUSIVE（独占）和SHARED（共享）
        Node node = new Node(Thread.currentThread(), mode);//多个线程在排队，一个线程附在一个Node节点，
        Node pred = tail;
        if (pred != null) {//尾节点不为null，其实被enq(node)重复了。
            node.prev = pred;
            if (compareAndSetTail(pred, node)) {//修改共享变量cas， 成员变量变了，局部变量没变。失败node.prev=pred无效。
                pred.next = node;//里面可以多线程都进来，但是不影响。因为pred=tail=新的节点node，重新获取了尾节点。
                return node;//返回新尾节点
            }
        }
        enq(node);//修改尾节点失败。自旋的方式继续加入等待队列。
        return node;//返回新尾节点
    }

    //将队列的头设置为节点，从而使其出列。仅由Acquire方法调用。为了GC，还可以空出未使用的字段，并抑制不必要的信号和遍历。
    private void setHead(Node node) {
        head = node;
        node.thread = null;
        node.prev = null;
    }

    //node可能是head节点可能是失效节点。
    private void unparkSuccessor(Node node) {
        int ws = node.waitStatus;
        if (ws < 0)//-1就设置为0，异常节点这里是1。    头结点要么是0要么是-1。头结点设置为0.
            compareAndSetWaitStatus(node, ws, 0);

        /*head下一个节点，从头结点开始一个个的找后继，直到把队列找完。
        next节点是正常的就找next，next不是正常的，就不能再找next，因为next.next有可能是自己。
        就tail往前找，从tail往前找prev一定能够吧所有正常节点找到（还会找到不正常的节点）。
        如果找到的这个节点status<=0，然后唤醒，但是这个节点异常了只是状态没有修改过来，
        那么唤醒的这个假正常节点就不会去获取锁，而是帮着正常节点做 ，做完退出。
        */
        
        Node s = node.next;//node=head，head.next不一定是初始节点，可能被改过指向曾经正常的一个节点，这个节点现在正常与否未知。
        //下一个节点s被取消，node还没来得及重新设置新的正常后继节点。队列还没有处于稳定状态。
        //第一个节点被取消，就从后往前找下一个状态正常节点。也相当于是head后面第一个status正常节点。
        
        if (s == null || s.waitStatus > 0) {
            s = null;
            for (Node t = tail; t != null && t != node; t = t.prev) //右边的正常节点。
                if (t.waitStatus <= 0)//  0/-1都唤醒
                    s = t;
        }
        if (s != null)//s可能=head，head.thread=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) {//-1， 如果头节点状态为SIGNAL，说明要唤醒下一个节点，并且设置0成功就唤醒下一个，
                    if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))//设置为0成功（没有异常）就去unparkSuccessor，设置为0失败就跳过unparkSuccessor再次从head开始，
                        continue;  
                    
                    unparkSuccessor(h);//唤醒下一个节点
                    
                //等于0  并且  设置-3失败，就跳过，  把头节点的状态改为PROPAGATE成功才会跳到下面的if
                } else if (ws == 0 && !compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
                    continue; // 
            }
            if (h == head) // head变化了，继续唤醒head，
                break;//头结点变了，head后面节点自行出队了，
        }
    }

    private void setHeadAndPropagate(Node node, int propagate) {
        Node h = head;  
        setHead(node);
        // 如果旧的头节点或新的头节点为空或者其等待状态小于0（表示状态为SIGNAL/PROPAGATE）
        if (propagate > 0 || h == null || h.waitStatus < 0 || (h = head) == null || h.waitStatus < 0) {
            Node s = node.next;//node下一个节点，需要传播
            if (s == null || s.isShared()) // 如果下一个节点为空，或者是需要获取读锁的节点
                doReleaseShared();//唤醒head下一个节点
            //一个节点A获取了读锁后，会唤醒下一个读节点B，这时候B也会获取读锁，然后B继续唤醒C，依次往复，
            //也就是说这里的节点是一个唤醒一个这样的形式，而不是一个节点获取了读锁后一次性唤醒后面所有的读节点。
        }
    }

    /* 所看到的所有成员变量都在工作内存里面，局部变量更在工作内存里面。 */
    
    //有可能是0变到1，也有可能是-1变到1， 
    private void cancelAcquire(Node node) {
        if (node == null)
            return;
        node.thread = null;//异常节点，thread先清空，
        
        /*失效节点：不断改变自己的前驱         在改变status   最后改变next*/
        
        Node pred = node.prev;//node就是头结点，pred就是null，
        while (pred.waitStatus > 0)//找到新的-1/0，跳过已经取消的节点。 
            node.prev = pred = pred.prev;//断开node.prev。node.prev只有节点自己线程修改不用cas，
        //while出来时候pred=0/-1,while之后pred可能变为1。  0/-1节点在任何时候都有可能变为1，每次判断都只是瞬间的值。
        
        /*pred = pred.prev;不是改变属性
        node.prev = pred是改变属性*/

        Node predNext = pred.next;//此时pred可能是0/-1节点也可能是1节点.

        /* 节点异常了只能通过status和thread看得出来。否则外界不知道异常了。别人也是通过status来看这个节点是不是异常了，所以有延时。 */
        
        node.waitStatus = Node.CANCELLED;//强制覆盖，不用cas，以这个为主。

        //修改队列。去掉的节点是尾节点就要修改，尾节点就不需要prev.next了。
        if (node == tail && compareAndSetTail(node, pred)) {//死循环的cas会重来，一次cas失败了就放弃让别人去做，优先级低于直接赋值。
            //修改tail为pred，修改失败：不是尾节点了，加进来了新的节点。
            //pred.next!=predNext就是有节点加进来了，并且pred.next=新的节点，就不置位null。
            compareAndSetNext(pred, predNext, null);//tail的next置位null，GC
            
        } else {//不是尾节点，或者是尾节点但是加进来了新的节点，
            int ws;
            if (pred != head  //node前面是head，就不要去设置后继关系，而是唤醒，
                    &&  
                    /* 再次判断pred的状态是正常=0/-1
                     有可能这时候prev=head，并且有可能head=0已经出队了，pred.thread = null就要唤醒node后面*/
                    
                    /*prev不是头结点并且异常了，如果不管了，如果后面正常节点阻塞了，并且前面没有正常节点
                    那么head=0 unlock出队失败时候，队列里面的就全阻塞了，就永远不能出队。*/
                    
                    ( (ws = pred.waitStatus) == Node.SIGNAL|| ( 
                            ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL) )   ) 
                    && pred.thread != null 
                ) 
            {
                //pred不是头节点，并且，pred正常 
                //有可能这时候prev=head，但是head=-1，可以正常唤醒。
                Node next = node.next;
                if (next != null && next.waitStatus <= 0)//next节点也可能是取消了。
                    //pred.next没有被修改。next不可能为null，因为线程退出了节点可能还在，
                    compareAndSetNext(pred, predNext, next);//把node也跳过，失败不重来，因为别的正常-1节点也会修改，让正常节点。
                
            } else {//node.prev=head，ndoe异常，
                //node不一定是紧挨着head的节点，正常节点在node后面并且在第一个栅栏里面， 
                //如果这里不唤醒，只是依靠unlock唤醒，但是unlock在head=0时候是不会唤醒的什么都不做的，unlock在这种情况不负责唤醒线程获取锁，
                //那么就该第一个栅栏里面的正常节点去获取锁，防止正常节点阻塞了，这里就要去唤醒，否则unlock出队失败就永远不能唤醒。
                
                //或者，node不是第一个节点但是prev状态值=1了，或者，node不是第一个节点prev状态值=0/-1但是prev的thread=null了
                unparkSuccessor(node);//唤醒node这个异常节点的后面节点
            }

            node.next = node; // help GC。断开node.next
        }
    }

    //前驱节点是-1就阻塞。前驱节点是0就是初始化设置为-1,并且清理失效的节点。直到找到-1为止。
    private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
        //第一次进来，pred.waitStatus=默认值0，然后设置=-1，parkAndCheckInterrupt()失败会再次进来，直接返回true，表示应该阻塞。
        //第一次进来不阻塞，第二次进来阻塞。
        int ws = pred.waitStatus;//0 1 -1 -2 -3。
        
        //前驱=-1，当前节点node应该阻塞。SIGNAL表示释放后需要唤醒后继节点。
        if (ws == Node.SIGNAL)//这一行pred=-1，下一行pred可能会变为1,
            return true;
        
        
        //其余返回false，当前节点不应该阻塞。
        //清理失效的节点，并把新的前驱节点设置为-1。跳过现在是1的，并且是1之后不会变回-1。
        if (ws > 0) {//waitStatus = 1，清理CACELLED节点。
            do {
                node.prev = pred = pred.prev;//pred往前进一个，
            } while (pred.waitStatus > 0);//<=0作为边界
            pred.next = node;//回指肯定成功。 直接赋值覆盖cas赋值。
         
        } else {//0或者-3 -2，是1不会变为-1。就是前驱后继关系。
            //ws此时=0/-3/-2就说明没有取消就设置为-1，ws=1说明取消了，不能设置为-1。
            
            /* 再次判断pred的状态为正常=0 */
            
            compareAndSetWaitStatus(pred, ws, Node.SIGNAL);//设置新的前驱waitStatus=-1，有可能失败。被自己改为了1就以1为主，这边失败算了。
            //有可能马上被设置为1，即使cas了也不保证cas下一行状态没改变，只是保证获取ws到改变期间没有变化，这一行之后变化了不管。
        }
        
        /*找前驱节点：不断改变自己的前驱       在改变找到节点的next  最后修改找到节点的status*/
        
        return false;
    }

    static void selfInterrupt() {
        //线程被打上中断标记。但是线程正常执行，只有判断是否中断然后return线程才会停止。否则跟没有中断是一样的。
        Thread.currentThread().interrupt();
    }

    private final boolean parkAndCheckInterrupt() throws InterruptedException   {//阻塞并看阻塞是否成功
        Thread t = Thread.currentThread();
        if(t.getName().equals("")  ) {
            throw new InterruptedException();
        }
        LockSupport.park(this);//阻塞，this=ReentrantLock对象。直到被唤醒或者中断。
        return Thread.interrupted();//唤醒时候，中断唤醒返回true，interrupted=true，获取到锁（设置了成员属性的值）之后还是会中断。并复位，
    }

    //返回true当前线程就阻塞（就没有获取锁），返回false就不阻塞（就获取了锁）。一次只能一个线程执行（exclusiveOwnerThread=的线程执行），其余阻塞
    // 节点加进去之后，就死循环（死循环也是在最前面才获取锁，否则死循环或者阻塞），
    final boolean acquireQueued(final Node node, int arg) throws InterruptedException   {
        boolean failed = true;
        try {
            boolean interrupted = false;
            //旋转1次，旋转2次，旋转3次，或者多次阻塞，compareAndSetWaitStatus(pred, ws, Node.SIGNAL)有可能一直失败，多次在于这里。
            for (;;) {
                final Node p = node.predecessor(); 
                //是最前面的节点（节点从前到后依次获取锁），并且获取锁成功，就不阻塞，这个节点退出链表，更新链表，Lock方法返回。
                
                if (p == head && tryAcquire(arg)) {//否则死循环（自旋出队）。获取锁的线程只有一个，所以这里是加锁。tryAcquire方法在Write锁里面会重写
                    //setHead()加锁了不用CAS（只有修改成员变量cas否则都是线程的局部内部变量）。
                    //head=node,node.thread=null,node.prev=null。thread就是调用这个函数的线程设置为null（已经获取了锁就移除这个节点）。
                    
                    //head指向正在运行的线程的节点，就是不在排队中的节点的线程。 如果不在队列的线程获取了锁，head不变继续指向。
                    //如果队列中的线程获取了锁，head就指向新的获取锁的线程的节点。
                    setHead(node);//node变成空节点并升级为头节点。    status=0/-1没变。
                    p.next = null; // help GC，node变为头结点,head节点gc，
//                    if(Thread.currentThread().getName().equals("1号窗口")  ) {
//                        throw new InterruptedException();
//                    }
                    failed = false;//不走cancelAcquire(node)，
//                    if(Thread.currentThread().getName().equals("1号窗口")  ) {
//                        throw new InterruptedException();
//                    }
                    return interrupted;//已经获取了锁，就不用中断了，lock方法返回void，不用阻塞了。先执行finally再return。
                }
                
                //不是最前面的节点，或者 是最前面的节点但是获取锁失败。判断当前线程是否需要阻塞。
                
                //shouldParkAfterFailedAcquire()判断当前线程是否需要阻塞 （通过前驱节点判断）
                //parkAndCheckInterrupt()阻塞当前线程 ，阻塞失败继续死循环。
                if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                    interrupted = true;//如果状态为true说明发生过中断，会补发一次中断，中断唤醒的线程应该去中断而不是继续执行，即调用interrupt()方法
            }
        } finally {//不异常也走这里然后return，
            if (failed)//node成为了头节点异常，线程退出，head节点还在，
                //抛出任何异常，则取消任务。这里不catch，外层函数要catch，否则异常一直在。
                cancelAcquire(node);
        }
    }

    //这个线程能够响应中断，即中断线程的等待状态
    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())
                    throw new InterruptedException();//线程中断唤醒抛出异常
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    private boolean doAcquireNanos(int arg, long nanosTimeout) throws InterruptedException {
        if (nanosTimeout <= 0L)
            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；否则返回true
                    return false;
                //不会一直阻塞等待唤醒，只会阻塞一定时间，
                if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);//阻塞剩余的时间
                if (Thread.interrupted())// 等待过程中，可以被中断，中断就抛异常，不像别的中断后继续运行，只是设置中断标记，然后我们自己去处理。
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }
    //ReadLock获取锁走这个方法，AQS排队，
    private void doAcquireShared(int arg) throws InterruptedException {
        final Node node = addWaiter(Node.SHARED);//ReadLock节点是共享模式，nextWaiter是一个空节点（共享模式是null【ReentrantLock和WriteLock】）
        boolean failed = true;
        try {
            boolean interrupted = false;
            for (;;) {//自旋
                final Node p = node.predecessor();
                if (p == head) {//是第一个节点。获取锁
                    int r = tryAcquireShared(arg);//尝试获取锁，返回-1获取锁失败，返回1获取锁成功。
                    if (r >= 0) {//获取成功, 
                        // 头节点后移并传播。传播即唤醒后面连续的读节点
                        setHeadAndPropagate(node, r);//node变为头结点
                        p.next = null; // help p GC
                        if (interrupted)//中断唤醒在获取的锁
                            selfInterrupt();//设置中断标记
                        failed = false;
                        return;
                    }
                }    //设置前面-1然后阻塞，
                    if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                        interrupted = true;
            }
        } finally {//不异常也走这里
            if (failed)
                cancelAcquire(node);//异常设置自己=1，并帮助清理AQS的异常节点，建立后驱或者唤醒后面节点
        }
    }

    private void doAcquireSharedInterruptibly(int arg) throws InterruptedException {//Semaphore排队，多线程
        final Node node = addWaiter(Node.SHARED);//共享节点，Semaphore可以多线程进入，所以跟读锁是一样的，
        boolean failed = true;
        try {
            for (;;) {
                final Node p = node.predecessor();
                if (p == head) {
                    int r = tryAcquireShared(arg);//获取许可，返回减1后的许可
                    if (r >= 0) {
                        setHeadAndPropagate(node, r);//r=0，说明没有许可，就不会去唤醒下一个节点
                        p.next = null; // help GC
                        failed = false;
                        return;
                    }
                }
                if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    /**
    以共享定时模式获取
     */
    private boolean doAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {
        if (nanosTimeout <= 0L)
            return false;
        final long deadline = System.nanoTime() + nanosTimeout;
        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 true;
                    }
                }
                nanosTimeout = deadline - System.nanoTime();
                if (nanosTimeout <= 0L)
                    return false;
                if (shouldParkAfterFailedAcquire(p, node) && nanosTimeout > spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                if (Thread.interrupted())
                    throw new InterruptedException();
            }
        } finally {
            if (failed)
                cancelAcquire(node);
        }
    }

    protected boolean tryAcquire(int arg) {
        throw new UnsupportedOperationException();
    }

    protected boolean tryRelease(int arg) {
        throw new UnsupportedOperationException();
    }

    protected int tryAcquireShared(int arg) {
        throw new UnsupportedOperationException();
    }

    protected boolean tryReleaseShared(int arg) {
        throw new UnsupportedOperationException();
    }

    protected boolean isHeldExclusively() {
        throw new UnsupportedOperationException();
    }
    
    //ReentrantLock和WriteLock获取锁，走这个方法，tryAcquire在ReentrantReadWrite里面有重写
    public final void acquire(int arg) throws InterruptedException   {//tryAcquire会先去获取锁，获取成功返回true否则false。
        //addWaiter()穿建一个独占的节点添加到尾节点去。 
        //如果获取失败，则向等待队列中添加一个独占模式的节点，并通过acquireQueued()阻塞的等待该节点被调用（即当前线程被唤醒）。
        //如果是因为被中断而唤醒的，则复现中断信号。
        //acquireQueued()检查node的前继节点是否是头节点。如果是，则尝试获取锁；如果不是，或是但获取所失败，都会尝试阻塞等待。
        //addWaiter时候线程异常了，不会吧head置为1.
        if (!tryAcquire(arg) && 
                //返回是否中断，如果返回中断，则调用当前线程的interrupt()方法
                acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
            
            selfInterrupt();//interrupted = true当前线程中断执行。重放acquireQueued里面的中断。
    }

    //跟acquire差不多
    public final void acquireInterruptibly(int arg) throws InterruptedException {
        if (Thread.interrupted())//线程中断标志为1
            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)) {//true就表示OwnerThread=null了state=0了，减少state和OwnerThread。
            //tryRelease()返回true表示已完全释放，可唤醒所有阻塞线程；否则没有完全释放，不需要唤醒。这个线程要再次unlock才去唤醒队列的节点。
            Node h = head;
            
            //头结点只能是0/-1不可能是1。头结点由第一个入队节点创建，第一个入队节点线程异常了也只会设置第一个节点=1，不会影响到头结点，不会设置到头结点=1。
            //头结点看成一直是正常节点，
            if (h != null && h.waitStatus != 0) 
                unparkSuccessor(h);//head.waitStatus=-1才进来，唤醒head的后继
            
            //h=null，头结点都还没有建立，队列也还没有建立。
            /*或者h!=null&&head.waitStatus==0，
             最近的正常节点不一定是紧挨着的节点，最近的正常节点中间可能还有异常节点。
             head.waitStatus变成-1是由head后面的最近正常节点设置的（不一定是紧挨着的节点），说明曾经有一个正常节点执行完了3步，这个正常节点是否还正常未知。
             head.waitStatus==0说明head后面都异常了，或者后面第一个正常节点（不一定是紧挨着的节点）还没有自旋到这一步，还没被阻塞 。说明没有曾经一个正常节点完成了3步，把他设置成-1。
             如果head后面的正常节点都阻塞了（仅仅只需要看最近的正常节点），必然会设置head=-1，并且是由最近正常节点设置的。 
            */
            //lock时候head.waitStatus==0不出对，说明都不做，head不改变。唤醒时候head不变，只有获取到锁之后，head变化。
            return true;
        }
        return false;//unlock就不会去唤醒等待的第一个节点
    }

    //ReadLock获取锁走这个方法，tryAcquireShared在ReentrantReadWrite里面，doAcquireShared在AQS里面，
    public final void acquireShared(int arg) throws InterruptedException {
        if (tryAcquireShared(arg) < 0)//获取共享锁，读锁，获取失败，排队。
            doAcquireShared(arg);//排队
    }

    public final void acquireSharedInterruptibly(int arg) throws InterruptedException {//Semaphore获取一个许可
        if (Thread.interrupted())
            throw new InterruptedException();
        if (tryAcquireShared(arg) < 0)//Semaphore获取一个许可，有许可只是没有获取到，就死循环获取许可，
            doAcquireSharedInterruptibly(arg);//只有在许可没了才去排队，Semaphore排队
    }

    public final boolean tryAcquireSharedNanos(int arg, long nanosTimeout) throws InterruptedException {
        if (Thread.interrupted())
            throw new InterruptedException();
        return tryAcquireShared(arg) >= 0 || doAcquireSharedNanos(arg, nanosTimeout);
    }

    public final boolean releaseShared(int arg) {// 读锁释放（共享锁），多线程访问
        if (tryReleaseShared(arg)) {//释放锁，释放之后state=0返回true。读锁全部释放完了，才会去唤醒AQS
            doReleaseShared();//唤醒head下一个
            return true;
        }
        return false;
    }

    public final boolean hasQueuedThreads() {
        return head != tail;
    }

    public final boolean hasContended() {
        return head != null;
    }

    public final Thread getFirstQueuedThread() {
        //前面是快速失败
        return (head == tail) ? null : fullGetFirstQueuedThread();
    }

    private Thread fullGetFirstQueuedThread() {
        /*
        第一个节点通常是head.next，尝试获取其线程字段，确保一致的读取：
         如果线程字段为空或s.prev不再是head，我们试了2次。
         */
        Node h, s;
        Thread st;
        if (((h = head) != null && (s = h.next) != null && s.prev == head && (st = s.thread) != null)
                || ((h = head) != null && (s = h.next) != null && s.prev == head && (st = s.thread) != null))
            return st;

        Node t = tail;
        Thread firstThread = null;
        while (t != null && t != head) {
            Thread tt = t.thread;
            if (tt != null)
                firstThread = tt;
            t = t.prev;
        }
        return firstThread;
    }

    public final boolean isQueued(Thread thread) {
        if (thread == null)
            throw new NullPointerException();
        for (Node p = tail; p != null; p = p.prev)
            if (p.thread == thread)
                return true;
        return false;
    }

    //第一个节点线程部位null并且不是共享的读锁
    protected final boolean apparentlyFirstQueuedIsExclusive() {
        Node h, s;
        return (h = head) != null && (s = h.next) != null && !s.isShared() && s.thread != null;
    }
    
    //h=t有可能是指向同一个，有可能都是null。h!=t有可能指向不同的，有可能head！=null但tail=null。
    //注意；一个节点变成null只能通过GC，有人指向就不会GC变成null，没有主动置为null的语句。中间节点的next不可能指向一个null，next指向的节点有人指向不会被GC，也没有主动设置为null的语句，
    /*队列的状态：1（false，获取锁）head tail都是null            2（true，排队）head!=null tail=null，head的next和prev都=null，有人在初始化队列，  
                 3（false，获取锁，此时有线程正在入队，不准确）head=tail!=null，但是next和prev都是null      4（false，获取锁）有第一个节点是当前线程，head tail都！=null，head.next=tail tail.next=null  
                   5（true，排队）有第一个节点不是当前线程，head tail都！=null，head.next=tail tail.next=null  */
    //h!=t && h.next=null,那么tail就等于null还没有初始化，head!=null。
    public final boolean hasQueuedPredecessors() {
        Node t = tail; 
        Node h = head;
        Node s;
        /*
         公平原则：没人占用锁时候，要不要去获取锁。有线程在队列里面，说明那些是获取锁失败的才去排队。没有线程获取锁，线程是第一个节点获取锁，第一个节点不是当前线程排队。
         当然这个不一定准确：有可能别的线程已经开始排队了，只是没有完全加入到队列，另一个线程过来还是可以立马获取锁。但是单单只看第一个节点存不存在，也不准确。
         */                                              
                           
        //返回true排队，true&&(true||)。true&&(false||true)。有第一个节点不是当前线程，或者 ，有别人在初始化队列，.
        //返回fasle获取锁：   false。true&&(false||false):对裂空没有线程，有第一个节点是当前线程
        return h != t && ((s = h.next) == null || s.thread != Thread.currentThread());
        //h!=t&&h.next=null 或者  h!=t&&h.next.thread!=currentThread()  返回true排队。否则获取锁。
        // 有人在初始化   或者    有第一个节点不是当前线程。
    }

    public final int getQueueLength() {//不是线程安全
        int n = 0;
        for (Node p = tail; p != null; p = p.prev) {
            if (p.thread != null)
                ++n;
        }
        return n;
    }

    public final Collection<Thread> getQueuedThreads() {//不是线程安全
        ArrayList<Thread> list = new ArrayList<Thread>();
        for (Node p = tail; p != null; p = p.prev) {
            Thread t = p.thread;
            if (t != null)
                list.add(t);
        }
        return list;
    }

    public final Collection<Thread> getExclusiveQueuedThreads() {//不是线程安全
        ArrayList<Thread> list = new ArrayList<Thread>();
        for (Node p = tail; p != null; p = p.prev) {
            if (!p.isShared()) {
                Thread t = p.thread;
                if (t != null)
                    list.add(t);
            }
        }
        return list;
    }

    public final Collection<Thread> getSharedQueuedThreads() {//不是线程安全
        ArrayList<Thread> list = new ArrayList<Thread>();
        for (Node p = tail; p != null; p = p.prev) {
            if (p.isShared()) {
                Thread t = p.thread;
                if (t != null)
                    list.add(t);
            }
        }
        return list;
    }

    public String toString() {
        int s = getState();
        String q = hasQueuedThreads() ? "non" : "";
        return super.toString() + "[State = " + s + ", " + q + "empty queue]";
    }

    final boolean isOnSyncQueue(Node node) {
        //=-2就是不在AQS的同步队列，在condition的等待队列， prev=null肯定不在AQS，便说明节点还在Condition队列中
        if (node.waitStatus == Node.CONDITION || node.prev == null)
            return false;
        // 说明当前Node的状态不是CONDITION，同时它既有prev节点也有next节点，那么说明它在AQS队列里   
        if (node.next != null)  
            return true;
        return findNodeFromTail(node);//node在不在AQS同步队列中
    }

    private boolean findNodeFromTail(Node node) {//node在不在AQS同步队列中
        Node t = tail;//从tail往前可以找到所有AQS的节点
        for (;;) {
            if (t == node)
                return true;
            if (t == null)
                return false;
            t = t.prev;
        }
    }

    final boolean transferForSignal(Node node) {
        //唤醒从-2变成0，condition加到AQS時候狀態是0，唤醒失败就是=1，await里面唤醒AQS时候异常了，设置为1了，就去唤醒下一个，
        //此时他不移到AQS继续放到condition队列，不是-2就表示已经加入到队列去了，
        if (!compareAndSetWaitStatus(node, Node.CONDITION, 0))
            return false;
        Node p = enq(node);//把节点加到AQS队列，直接把condition節點全部拿過來，屬性值=-2不變，返回AQS尾节点就是前面一个节点
        int ws = p.waitStatus;
        if (ws > 0 || !compareAndSetWaitStatus(p, ws, Node.SIGNAL))//AQS前面节点异常了，或者设置-1失败了，就唤醒自己，防止自己在AQS上的时候不能够唤醒去获取锁。
            LockSupport.unpark(node.thread);//node移到AQS唤醒并且return true，
        //ws<=0&&compareAndSetWaitStatus(p,ws,-1)成功，node移到AQS不唤醒并且return true。
        return true;
    }

    //中断唤醒时候=-2没有开始加入AQS返回-1，=0开始加入AQS返回1，
    final boolean transferAfterCancelledWait(Node node) {
        //中断唤醒，但是！=-2，说明还没有signal（有可能signal了只是还没有改变状态），還沒有加入隊列，幫助加入AQS隊列，
        if (compareAndSetWaitStatus(node, Node.CONDITION, 0)) { 
            enq(node);
            return true;
        }
        //不是-2已经设置为0了，已经signal了改变状态=0了，只是没有执行到加入到队列这行，等待signal线程加入到AQS队列，
        while (!isOnSyncQueue(node))//不在AQS队列就让步。等著加到AQS去
            Thread.yield();
        return false;
    }

    final int fullyRelease(Node node) {
        boolean failed = true;
        try {
            int savedState = getState();//Sync的state
            //unlock调用release(1)，这里全部释放。
            if (release(savedState)) {//通过head唤醒AQS队列中下一个节点。state变成0。release成功返回true没有唤醒成功返回false
                failed = false;
                return savedState;
            } else {
                throw new IllegalMonitorStateException();
            }
        } finally {
            if (failed)//release(savedState)异常了，就设置condition队列中的自己=1，
                node.waitStatus = Node.CANCELLED;//出现异常=1
        }
    }

    public final boolean owns(ConditionObject condition) {
        return condition.isOwnedBy(this);
    }

    public final boolean hasWaiters(ConditionObject condition) {//不是线程安全
        if (!owns(condition))
            throw new IllegalArgumentException("Not owner");
        return condition.hasWaiters();
    }

    public final int getWaitQueueLength(ConditionObject condition) {//不是线程安全
        if (!owns(condition))
            throw new IllegalArgumentException("Not owner");
        return condition.getWaitQueueLength();
    }

    public final Collection<Thread> getWaitingThreads(ConditionObject condition) {//不是线程安全
        if (!owns(condition))
            throw new IllegalArgumentException("Not owner");
        return condition.getWaitingThreads();
    }

    //内部类，可以使用外部类的方法和属性
    public class ConditionObject implements Condition, java.io.Serializable {
        private static final long serialVersionUID = 1173984872572414699L;
        private transient Node firstWaiter;//Condition的等待队列的头尾。AQS有一个队列，Condition有一个队列。
        private transient Node lastWaiter;

        public ConditionObject() {}

        private Node addConditionWaiter() {
            //Condition对队列的操作没考虑并发，因为对应的操作都是在线程获得锁之后才进行的
            
            Node t = lastWaiter;
            //尾节点!=-2就清除，Condition里面的节点状态只能是0和-2，否则就是无效节点
            if (t != null && t.waitStatus != Node.CONDITION) {//=1，
                unlinkCancelledWaiters();
                t = lastWaiter;
            }
            //创建新的节点放到Condition队列，移除AQS节点。
            //AQS节点prev！=null,next只有最后一个=null。
            //Condition节点，prev=next=null，nextWaiter只有最有一个=null。 
            Node node = new Node(Thread.currentThread(), Node.CONDITION);
            if (t == null)
                firstWaiter = node;
            else
                t.nextWaiter = node;
            lastWaiter = node;
            return node;
        }

        //
        private void doSignal(Node first) {
            do {
                if ((firstWaiter = first.nextWaiter) == null)//只有一个，并且移除了，就都是null。
                    lastWaiter = null;
                first.nextWaiter = null;//把nextWaiter置为了null，
                //把condition的第一個移到AQS去，不一定喚醒線程，
            } while (!transferForSignal(first) && (first = firstWaiter) != null);
        }

        //condition隊列移到AQS隊列，
        private void doSignalAll(Node first) {
            lastWaiter = firstWaiter = null;
            do {
                Node next = first.nextWaiter;
                first.nextWaiter = null;
                transferForSignal(first);
                first = next;
            } while (first != null);
        }

        //从第一个到最后一个，清除无效!=-2的节点。单向链表。
        private void unlinkCancelledWaiters() {
            Node t = firstWaiter;
            Node trail = null;
            while (t != null) {
                Node next = t.nextWaiter;
                if (t.waitStatus != Node.CONDITION) {
                    t.nextWaiter = null;
                    if (trail == null)
                        firstWaiter = next;
                    else
                        trail.nextWaiter = next;
                    if (next == null)
                        lastWaiter = trail;
                } else
                    trail = t;
                t = next;
            }
        }

        //唤醒Condition队列第一个非CANCELLED节点。
        public final void signal() {
            if (!isHeldExclusively())//获得锁的线程是不是当前线程，当前线程没有获取锁，
                throw new IllegalMonitorStateException();
            Node first = firstWaiter;
            if (first != null)
                doSignal(first);
        }

        //condition全部移到AQS
        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;
            while (!isOnSyncQueue(node)) {
                LockSupport.park(this);
                if (Thread.interrupted())//和await()区别是线程中断不会退出循环
                    interrupted = true;
            }
            try {   //恢复之前的锁状态并相应中断
                if (acquireQueued(node, savedState) || interrupted)
                    selfInterrupt();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        private static final int REINTERRUPT = 1;//线程在等待过程中发生了中断，但不需要抛出异常
        private static final int THROW_IE = -1;//线程在等待过程中发生了中断，且需要抛出异常

        //没有中断返回0，中断返回-1说明中断时候没有调用signal抛出异常，返回1说明中断时候调用了signal设置自己中断标记。
        private int checkInterruptWhileWaiting(Node node) {
            return Thread.interrupted() ? (transferAfterCancelledWait(node) ? THROW_IE : REINTERRUPT) : 0;
        }

        private void reportInterruptAfterWait(int interruptMode) throws InterruptedException {
            if (interruptMode == THROW_IE)
                throw new InterruptedException();
            else if (interruptMode == REINTERRUPT)
                selfInterrupt();
        }

        //当前获取lock的线程进入到等待队列。  只有获取锁的线程才进来，单线程的。
        public final void await() throws InterruptedException {
            if (Thread.interrupted()) throw new InterruptedException();
            //将当前线程包装成Node（只要了線程屬性，其餘屬性沒要），尾插入到Condition等待队列中，
            Node node = addConditionWaiter();
            
            //释放锁，设置state=0，清空owenerThread，唤醒AQS，
            //记录之前的state，唤醒后需要恢复状态，后续unlock()也要unlock这么多次不然将报错。
            //线程从lock开始到这一行，都是要获取锁的，所以是线程安全的，。 
            int savedState = fullyRelease(node); 
            //await开始一直到上面一行，都是线程安全的，下面就不线程安全了。
            
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {//当前节点到AQS队列之后就退出while循环，唤醒时候有可能不在AQS队列上就阻塞直到在AQS队列上。
                LockSupport.park(this);//当前线程在condition上阻塞，等著移到AQS，然後在AQS隊列裡面喚醒。喚醒時候已經在AQS隊列裡面了。
                
                /* 如果是中断唤醒，发生时期是任意的。可能在condition里面可能在AQS里面 */
                
                //中断唤醒，不是AQS的head唤醒，有可能还不在AQS队列里面。checkInterruptWhileWaiting会帮助加入队列，
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)//等于0就不是中断唤醒，=-1抛出异常 =1设置中断标记
                    //没有开始加入AQS返回-1，=0开始加入AQS返回1，
                    
                    break;//中断唤醒就跳出while，正常唤醒就继续while看是不是在AQS队列
            }
            //在AQS队列上唤醒，尝试获取AQS的鎖，可能会再次在AQS上阻塞，恢复await前的状态savedState，
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)//-1
                //AQS唤醒了，获取到锁了，
                //后面代码又是线程安全的。
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null) // 清除ConditioN队列中 != -2 的节点
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);//-1就抛出异常，1就设置自己中断标记。
        }

        public final long awaitNanos(long nanosTimeout) throws InterruptedException {
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();//加入Condition队列
            int savedState = fullyRelease(node);//释放锁
            final long deadline = System.nanoTime() + nanosTimeout;//过期时间点
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                if (nanosTimeout <= 0L) {
                    transferAfterCancelledWait(node);//加入队列
                    break;
                }
                if (nanosTimeout >= spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                //判断线程是否被中断
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
                nanosTimeout = deadline - System.nanoTime();
            }
            //响应中断
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null)
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
            return deadline - System.nanoTime();//返回耗时
        }

        public final boolean awaitUntil(Date deadline) throws InterruptedException {
            long abstime = deadline.getTime();
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            boolean timedout = false;
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                if (System.currentTimeMillis() > abstime) {
                    timedout = transferAfterCancelledWait(node);
                    break;
                }
                LockSupport.parkUntil(this, abstime);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null)
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
            return !timedout;
        }

        public final boolean await(long time, TimeUnit unit) throws InterruptedException {
            long nanosTimeout = unit.toNanos(time);
            if (Thread.interrupted())
                throw new InterruptedException();
            Node node = addConditionWaiter();
            int savedState = fullyRelease(node);
            final long deadline = System.nanoTime() + nanosTimeout;
            boolean timedout = false;
            int interruptMode = 0;
            while (!isOnSyncQueue(node)) {
                if (nanosTimeout <= 0L) {
                    timedout = transferAfterCancelledWait(node);
                    break;
                }
                if (nanosTimeout >= spinForTimeoutThreshold)
                    LockSupport.parkNanos(this, nanosTimeout);
                if ((interruptMode = checkInterruptWhileWaiting(node)) != 0)
                    break;
                nanosTimeout = deadline - System.nanoTime();
            }
            if (acquireQueued(node, savedState) && interruptMode != THROW_IE)
                interruptMode = REINTERRUPT;
            if (node.nextWaiter != null)
                unlinkCancelledWaiters();
            if (interruptMode != 0)
                reportInterruptAfterWait(interruptMode);
            return !timedout;
        }
        //判断Condition是否属于sync.
        final boolean isOwnedBy(AbstractQueuedSynchronizer1 sync) {
            return sync == AbstractQueuedSynchronizer1.this;
        }

        protected final boolean hasWaiters() {//不是线程安全
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
                if (w.waitStatus == Node.CONDITION)
                    return true;
            }
            return false;
        }

        protected final int getWaitQueueLength() {//不是线程安全
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            int n = 0;
            for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
                if (w.waitStatus == Node.CONDITION)
                    ++n;
            }
            return n;
        }

        protected final Collection<Thread> getWaitingThreads() {//不是线程安全
            if (!isHeldExclusively())
                throw new IllegalMonitorStateException();
            ArrayList<Thread> list = new ArrayList<Thread>();
            for (Node w = firstWaiter; w != null; w = w.nextWaiter) {
                if (w.waitStatus == Node.CONDITION) {
                    Thread t = w.thread;
                    if (t != null)
                        list.add(t);
                }
            }
            return list;
        }
    }
    
    static final class Node {
        //节点是共享节点
        static final Node SHARED = new Node();
        // 节点是独占节点
        static final Node EXCLUSIVE = null;
        //由于超时或中断，此节点被取消。  
        static final int CANCELLED = 1;
        //-1，唤醒，这个节点成为head结点时候，unlock会去通过head唤醒后继节点
        static final int SIGNAL = -1;
        //表示当前节点在等待condition，即在condition队列中；
        static final int CONDITION = -2;
        //表示releaseShared需要被传播给后续节点（仅在共享模式下使用）；
        static final int PROPAGATE = -3;
        volatile int waitStatus;//默认0，
        //前继节点；
        volatile Node prev;
        //后继节点；
        volatile Node next;
        //当前线程。
        volatile Thread thread;

        //condition节点的属性，ReentrantLock时候nextWaiter=null，
        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
            this.name = "头结点";
        }
        volatile String name;
        Node(Thread thread, Node mode) { //用于锁
            this.nextWaiter = mode;//独占锁的nextWaiter是模式=Node.EXCLUSIVE=null，
            this.thread = thread;
            this.name = this.thread.getName();
        }

        Node(Thread thread, int waitStatus) { //用于Condition
            this.waitStatus = waitStatus;
            this.thread = thread;
            this.name = this.thread.getName();
        }
        public String toString() {
            return "name："+this.name+"，prev：" + prev.name + "，next：" + next.name;
        }
    }

    //head指向获取锁的线程的节点，仅仅保存next结点的引用。。如果是没有入队的线程获取锁，head不变。head节点是一个哨兵节点 ，头结点不存储Thread，仅
    private transient volatile Node head;

    private transient volatile Node tail;//tail指向链表的最后一个节点

    //如果没有记录重入次数，则第一次释放锁时，会一次性把ownerThread多次重入的锁都释放掉，而此时“锁中的代码”还没有执行完成，造成混乱。
    private volatile int state;//所有者线程已经重复获取该锁的次数，每次加1。
    
    private static Unsafe unsafe;
    private static final long stateOffset;//state
    private static final long headOffset;//head
    private static final long tailOffset;//tail
    private static final long waitStatusOffset;//Node.waitStatus
    private static final long nextOffset;//Node.next

    static {
        try {
            unsafe = java.security.AccessController
                    .doPrivileged(new java.security.PrivilegedExceptionAction<sun.misc.Unsafe>() {
                        public sun.misc.Unsafe run() throws Exception {
                            Class<sun.misc.Unsafe> k = sun.misc.Unsafe.class;
                            for (java.lang.reflect.Field f : k.getDeclaredFields()) {
                                f.setAccessible(true);
                                Object x = f.get(null);
                                if (k.isInstance(x))
                                    return k.cast(x);
                            }
                            throw new NoSuchFieldError("the Unsafe");
                        }
                    });
            stateOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer1.class.getDeclaredField("state"));
            headOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer1.class.getDeclaredField("head"));
            tailOffset = unsafe.objectFieldOffset(AbstractQueuedSynchronizer1.class.getDeclaredField("tail"));
            waitStatusOffset = unsafe.objectFieldOffset(Node.class.getDeclaredField("waitStatus"));
            nextOffset = unsafe.objectFieldOffset(Node.class.getDeclaredField("next"));

        } catch (Exception ex) {
            throw new Error(ex);
        }
    }
    
    protected final boolean compareAndSetState(int expect, int update) {
        return unsafe.compareAndSwapInt(this, stateOffset, expect, update);
    }
    
    private final boolean compareAndSetHead(Node update) {
        return unsafe.compareAndSwapObject(this, headOffset, null, update);
    }

    private final boolean compareAndSetTail(Node expect, Node update) {
        return unsafe.compareAndSwapObject(this, tailOffset, expect, update);
    }

    private static final boolean compareAndSetWaitStatus(Node node, int expect, int update) {
        return unsafe.compareAndSwapInt(node, waitStatusOffset, expect, update);
    }

    private static final boolean compareAndSetNext(Node node, Node expect, Node update) {
        return unsafe.compareAndSwapObject(node, nextOffset, expect, update);
    }
}