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

final boolean acquireQueued(final Node node, int arg) {boolean failed = true;//标记是否成功拿到资源try {boolean interrupted = false;//标记等待过程中是否被中断过//又是一个“自旋”！这里自旋什么时候会跳出呢？看return可知，只有在获取到了锁会退出，如果获取不到，那么就会被unpark把线程带到wait状态。　　　　　　//当unpark唤醒后会继续自旋看自己是否是老二，一般情况下就是了，然后退出循环，返回中断状态，用作补偿处理，比较wai是不响应中断的for (;;) {final Node p = node.predecessor();//拿到前驱//如果前驱是head，即该结点已成老二，那么便有资格去尝试获取资源（可能是老大释放完资源唤醒自己的，当然也可能被interrupt了）。if (p == head && tryAcquire(arg)) {setHead(node);//拿到资源后，将head指向该结点。所以head所指的标杆结点，就是当前获取到资源的那个结点或null。p.next = null; // setHead中node.prev已置为null，此处再将head.next置为null，就是为了方便GC回收以前的head结点。也就意味着之前拿完资源的结点出队了！failed = false;return interrupted;//返回等待过程中是否被中断过
            }//如果自己可以休息了，就进入waiting状态，直到被unpark()if (shouldParkAfterFailedAcquire(p, node) &&parkAndCheckInterrupt())interrupted = true;//如果等待过程中被中断过，哪怕只有那么一次，就将interrupted标记为true
        }} finally {if (failed)cancelAcquire(node);}
}

private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {int ws = pred.waitStatus;//拿到前驱的状态if (ws == Node.SIGNAL)//如果已经告诉前驱拿完号后通知自己一下，那就可以安心休息了return true;if (ws > 0) {/** 如果前驱放弃了，那就一直往前找，直到找到最近一个正常等待的状态，并排在它的后边。* 注意：那些放弃的结点，由于被自己“加塞”到它们前边，它们相当于形成一个无引用链，稍后就会被保安大叔赶走了(GC回收)！*/do {node.prev = pred = pred.prev;} while (pred.waitStatus > 0);pred.next = node;} else {//如果前驱正常，那就把前驱的状态设置成SIGNAL，告诉它拿完号后通知自己一下。有可能失败，人家说不定刚刚释放完呢！
        compareAndSetWaitStatus(pred, ws, Node.SIGNAL);}return false;
}

private void unparkSuccessor(Node node) {//这里，node一般为当前线程所在的结点。int ws = node.waitStatus;if (ws < 0)//置零当前线程所在的结点状态，允许失败，使得找节点只需找<0的，可以跳过头节点。compareAndSetWaitStatus(node, ws, 0);Node s = node.next;//找到下一个需要唤醒的结点s，先从头结点开始，不对就从尾部开始往前找到最前的if (s == null || s.waitStatus > 0) {//如果为空或已取消s = null;for (Node t = tail; t != null && t != node; t = t.prev)if (t.waitStatus <= 0)//从这里可以看出，<=0的结点，都是还有效的结点。s = t;}if (s != null)LockSupport.unpark(s.thread);//唤醒
}

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

 /*** Acquires in shared uninterruptible mode.* @param arg the acquire argument*/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) {setHeadAndPropagate(node, r);  //r>0，唤醒后面线程p.next = null; // help GCif (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; setHead(node);//head指向自己//如果还有剩余量，继续唤醒下一个邻居线程if (propagate > 0 || h == 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) {if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))continue;unparkSuccessor(h);//唤醒后继
            }else if (ws == 0 &&!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))continue;}if (h == head)// head发生变化，当唤醒成功后，老二结点会自动替换head为自己，所以这里就不再相等，释放成功break;}
}