AQS学习记录
一、AQS的独占模式
1、获取资源
acquire办法用于线程获取资源，获取不到就进入期待队列，并设置为独占模式，胜利后，设置线程中断
public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }AQS只是一个框架，具体资源的获取/开释形式交由自定义同步器去实现，这里的接口没有定义成abstract是因为独占模式下只需实现tryAcquire-tryRelease，而共享模式下只用实现tryAcquireShared-tryReleaseShared。因而没必要定义成abstract类型。
protected boolean tryAcquire(int arg) { throw new UnsupportedOperationException(); }如果获取资源失败，就调用addWaiter办法，结构以后线程的Node节点，设置为期待队列的尾节点
private Node addWaiter(Node mode) { Node node = new Node(Thread.currentThread(), mode); // 通过CAS，将新的Node设置为tail节点 Node pred = tail; if (pred != null) { node.prev = pred; if (compareAndSetTail(pred, node)) { pred.next = node; return node; } } enq(node); // 如果设置尾节点失败，则通过自旋的形式来设置尾节点 return node; }设置尾节点失败时，则调用enq(final Node node)办法，通过自旋的形式，将以后node设置为尾节点直到胜利。
private Node enq(final Node node) { for (;;) { //这里有个细节，将volatile变量tail赋给t,这样不必每次去主存读取，进步了效率 Node t = tail; // 如果 tail 是 null，就创立一个虚构节点，同时指向 head 和 tail，称为 初始化。 // 每个节点都必须设置前置节点的 ws 状态为 SIGNAL，所以必须要一个前置节点， // 对于第一个节点怎么办？它是没有前置节点的，这里须要创立一个假的。 if (t == null) { if (compareAndSetHead(new Node())) tail = head; } else { //通过CAS将新节点追加到 tail 节点前面，并更新队列的 tail 为新节点,直到胜利 node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } } }当初再回头看acquireQueued(addWaiter(Node.EXCLUSIVE), arg))办法，该办法则是通过自旋形式获取资源，for循环中：判断以后node的前驱节点是不是Head节点（Head节点仅仅代表头结点，外面没有寄存线程援用，示意以后线程曾经获取到资源），如果是，则以后node尝试获取资源，获取资源胜利，则将本人更新为Head节点，未获取到资源，则waite。
final boolean acquireQueued(final Node node, int arg) { boolean failed = true; //标记是否胜利拿到资源 try { boolean interrupted = false; for (;;) { final Node p = node.predecessor(); //获取node的前驱节点，留神node当初是尾节点了 if (p == head && tryAcquire(arg)) { setHead(node); //node设置为Head节点（Head节点不寄存线程援用） p.next = null; // 旧的头结点出列，帮忙GC回收 failed = false; return interrupted; //返回node中线程在期待过程中是否被中断过 } // 以后线程进入waite状态，且将前驱节点的转态设置为signal，用于唤醒本人，返回中断状态状态 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; //如果期待过程中被中断过就将interrupted标记置为true } } finally { if (failed) cancelAcquire(node); //仅在获取锁产生异样的时候，勾销以后node获取资源的资格 } }shouldParkAfterFailedAcquire办法次要是将前驱节点的转态设置为signal（如果前驱转态>0，即勾销转态，那么就跳过它，找到未被勾销的节点作为以后node的前驱节点），这样以后node就能够平安地进入阻塞状态，一旦waiteStatus为signal的前驱节点开释锁，就会唤醒以后Node。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { int ws = pred.waitStatus; if (ws == Node.SIGNAL) // 如果他的上一个节点的 ws 是 SIGNAL，他就须要阻塞。 return true; if (ws > 0) { // 如果前驱节点的状态为勾销，则将前驱节点的前驱作为node的前驱 // 按此流程，始终找到未勾销状态的前驱节点 do { node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } else { // 如果没有勾销 || 0 || CONDITION || PROPAGATE，那么就将后任的 ws 设置成 SIGNAL. // 必须是 SIGNAL ，是心愿本人的上一个节点在开释锁的时候，告诉本人（让本人获取锁） compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false;}parkAndCheckInterrupt该办法用于阻塞以后的线程，并返回以后线程的中断状态（留神：Thread.interrupted()办法会革除中断状态）
private final boolean parkAndCheckInterrupt() { LockSupport.park(this); //将以后线程阻塞 return Thread.interrupted();//如果被唤醒，查看本人是不是被中断的。}下面提到acquireQueued(final Node node, int arg) 中，获取锁的形式是一个死循环，胜利：会将的标记位failed（标记以后Node是否胜利获取资源）置为false，如果失败：抛出异样，则执行执行finally中cancelAcquire(node)办法，勾销以后线程申请资源的操作。该办法负责将须要勾销的node踢出期待队列
private void cancelAcquire(Node node) { if (node == null) return; node.thread = null; // 跳过被勾销的前驱节点 Node pred = node.prev; while (pred.waitStatus > 0) node.prev = pred = pred.prev; // 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; // 如果node是tail节点，则比较简单，间接移出队列，将pred设置为tailed节点 if (node == tail && compareAndSetTail(node, pred)) { compareAndSetNext(pred, predNext, null); } else { int ws; // 如果pred不是head节点，则肯定要设置它的ws为signal，用于告诉前面节点去获取资源 if (pred != head && ((ws = pred.waitStatus) == Node.SIGNAL || (ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) && pred.thread != null) { Node next = node.next; //走到这里，阐明node不是tail，则next！=null? 这里将满足条件的next设置为pred.next,否则维持不变 if (next != null && next.waitStatus <= 0) compareAndSetNext(pred, predNext, next); } else { unparkSuccessor(node); } node.next = node; // help GC } }当下面的办法cancelAcquire(node)中，pred为head节点，或者未胜利设置signal时，如果勾销了node,那么后继节点就没人能唤醒，unparkSuccessor(node) 办法负责从tail开始遍历，找到node前面第一个未被勾销的节点,将其唤醒。
这里解析下：之所以从尾部开始遍历，是为了能保障遍历到所有的节点.比方，以后node是前tail节点，新的node2正在变成tail节点，然而addWaiter中 pred.next = node;并不是原子操作，很可能这步还未来得及执行，如果正向遍历，node.next，会为null,就会脱漏新退出的节点，然而从tail开始遍历必定没问题，因为在设置tail节点时，compareAndSetTail(pred, node)是原子操作。
private void unparkSuccessor(Node node) { int ws = node.waitStatus; if (ws < 0) compareAndSetWaitStatus(node, ws, 0); //从tail开始遍历，找到一个未被勾销的节点node,将其唤醒 Node s = node.next; if (s == null || s.waitStatus > 0) { s = null; for (Node t = tail; t != null && t != node; t = t.prev) if (t.waitStatus <= 0) s = t; } if (s != null) LockSupport.unpark(s.thread); }开释资源
开释资源的的办法tryRelease(arg)和tryAcquire(arg)一样，都是交给子类去具体实现，胜利开释资源后，须要调用unparkSuccessor(h)，从tail开始，唤醒一个期待状态为非勾销状态的node。
public final boolean release(int arg) { if (tryRelease(arg)) { Node h = head; if (h != null && h.waitStatus != 0) unparkSuccessor(h); return true; } return false; }外部类Node中几个参数
- static final int CANCELLED = 1 : 示意以后的线程被勾销
- static final int SIGNAL = -1 : 前驱节点期待状态设置为SIGNAL，在开释锁时，会告诉后继节点。
- static final int CONDITION = -2 ：该标识的结点处于期待队列中，结点的线程期待在Condition上，当其余线程调用了Condition的signal()办法后，CONDITION状态的结点将从期待队列转移到同步队列中，期待获取同步锁。
- static final int PROPAGATE = -3 ：与共享模式相干，在共享模式中，该状态标识结点的线程处于可运行状态。
- 0状态：值为0，代表初始化状态， AQS在判断状态时，通过用waitStatus>0示意勾销状态，而waitStatus<0示意无效状态。