【同步队列 AQS】【ReadWriteLock】【ReentrantLock】【CountDownLatch和CyclicBarrier】
模型：
AQS是整个Current包的核心，Volatile和CAS是可以保证设置state值的原子性，下面是AQS的整个构造：
就是上图的构造，结合volatile（上图的volatile int state），CAS（各种如compareAndSetTail()方法），for(;;)自旋，整个concurrent包的灵魂就出来了。这里明确一下，state是多线程访问的。
同步队列：
都是已经被唤醒的，等待获取锁的队列。
等待队列（Condition）：
被Condition await（）的队列。一个Condition对应一个等待队列。
public class ConditionObject implements Condition, java.io.Serializable { /** First node of condition queue. */ private transient Node firstWaiter; /** Last node of condition queue. */ private transient Node lastWaiter; }
其实Condition比起Java提供的synchronized锁的 Object.wait() 更灵活，他们的特点是：
- 一般获取锁和释放锁都是代码段，Condition提供了一种可以在代码段中释放锁，等待某种条件到的后再获取锁的能力，其中释放锁和获取锁都是自动的
- 等待同一个条件的线程，都会在一个队列中，他们就是等待队列，在等待队列中的线程都没有锁，等条件到达后会被转移到同步队列中去争取锁。
资源
state初始化为0，表示未锁定状态。A线程lock()时，会调用tryAcquire()独占该锁并将state+1。此后，其他线程再tryAcquire()时就会失败，直到A线程unlock()到state=0（即释放锁）为止，其它线程才有机会获取该锁。当然，释放锁之前，A线程自己是可以重复获取此锁的（state会累加），这就是可重入的概念。但要注意，获取多少次就要释放多么次，这样才能保证state是能回到零态的。
Node节点：
Node结点是对每一个访问同步代码的线程的封装，其包含了需要同步的线程本身以及线程的状态，如是否被阻塞，是否等待唤醒，是否已经被取消等。变量waitStatus则表示当前被封装成Node结点的等待状态，共有4种取值CANCELLED、SIGNAL、CONDITION、PROPAGATE。
- CANCELLED：值为1，在同步队列中等待的线程等待超时或被中断，需要从同步队列中取消该Node的结点，其结点的waitStatus为CANCELLED，即结束状态，进入该状态后的结点将不会再变化。
- SIGNAL：值为-1，意味着其后继者需要被uparking，其中一般是在释放锁的时候，去唤醒后继。
- 注释：waitStatus value to indicate successor's thread needs unparking
- 后继节点被唤醒后，如果状态正常，会去争取state锁，争取成功后会把头节点设置为自己，从而释放旧节点。
- 在线程入队的时候，会从队尾开始往队头方向，找到一个非取消的节点通过CAS设置为SIGNAL
- CONDITION：值为-2，与Condition相关，该标识的结点处于等待队列中，结点的线程等待在Condition上，当其他线程调用了Condition的signal()方法后，CONDITION状态的结点将从等待队列转移到同步队列中，等待获取同步锁。
- PROPAGATE：值为-3，与共享模式相关，在共享模式中，该状态标识结点的线程处于可运行状态。
- 0状态：值为0，代表初始化状态。
static final class Node { /** Marker to indicate a node is waiting in shared mode */ static final Node SHARED = new Node(); /** Marker to indicate a node is waiting in exclusive mode */ static final Node EXCLUSIVE = null; /** waitStatus value to indicate thread has cancelled */ static final int CANCELLED = 1; /** waitStatus value to indicate successor's thread needs unparking */ static final int SIGNAL = -1; /** waitStatus value to indicate thread is waiting on condition */ static final int CONDITION = -2; /** * waitStatus value to indicate the next acquireShared should * unconditionally propagate */ static final int PROPAGATE = -3; volatile int waitStatus; volatile Node prev; volatile Node next; volatile Thread thread; Node nextWaiter; }
AQS在判断状态时，通过用waitStatus>0表示取消状态，而waitStatus<0表示有效状态。
初认识AQS只需要知道用它分获取和释放两种操作，每个操作分为独占和共享，也就是acqurie、release、acquireShared、releaseshare这四个方法，可以多个子类同步器，如CyclicBarrire
独占锁
还有得到个好东西，一图明确acquire()方法，如下图：
注意上面所说的，是老二且拿到号，那么把当前节点设置为头节点，就说利用头节点的状态SIGNAL
public final void acquire(int arg) { if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg)) selfInterrupt(); }
其实比较关心的就是如何去获取锁的，state的值一般代表占取的资源数，所以很明显如果没有争夺那就是0，所以tryAcquire就是想获取，成功的标志是把state变成1，当然这个方法公平锁和非公平锁的实现是不一样的。
/** * Fair version of tryAcquire. Don't grant access unless * recursive call or no waiters or is first. */ protected final boolean tryAcquire(int acquires) { final Thread current = Thread.currentThread(); int c = getState(); if (c == 0) { if (!hasQueuedPredecessors() && compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; }
附带acquire()的总结：
- 调用自定义同步器的tryAcquire()尝试直接去获取资源，如果成功则直接返回；
- 没成功，则addWaiter()将该线程加入等待队列的尾部，并标记为独占模式；
- acquireQueued()会自旋进入队列，使线程在等待队列中休息，有机会时（轮到自己，会被unpark()）会去尝试获取资源。获取到资源后才返回。如果在整个等待过程中被中断过，则返回true，否则返回false。
- 注意，找队列安全点的过程中，如果发现找到了head，那么会继续去获取锁。
- 其中 parkAndCheckInterrupt() 方法是调用线程的park进入等待状态的。
- 如果线程在等待过程中被中断过，它是不响应的。只是获取资源后才再进行自我中断selfInterrupt()，将中断补上。
这里有个有趣的问题就是在加入等待队列之后，线程是否应该进入wait状态【图中的park（），其实是用Unsafe.unpark实现的。unpark使得线程不需要获取锁进入wait状态】,加入队尾后，利用acquireQueued休息：
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); } }
acquireQueued方法是如何找到安全点的呢，找安全点其实就是找到一个前驱节点，该节点的waitStatus == Node.SIGNAL，而这个整型值为-1，这个标志的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; }
介绍下waitStatus的状态取：
2、如果pred的waitStatus > 0，表明pred的线程状态CANCELLED，需从队列中删除。
3、如果pred的waitStatus为Node.SIGNAL，则通过LockSupport.park()方法把线程A挂起，并等待被唤醒。
/** waitStatus value to indicate thread has cancelled */ static final int CANCELLED = 1; /** waitStatus value to indicate successor's thread needs unparking */ static final int SIGNAL = -1; /** waitStatus value to indicate thread is waiting on condition */ static final int CONDITION = -2; /** * waitStatus value to indicate the next acquireShared should * unconditionally propagate */ static final int PROPAGATE = -3;
我们得知，如果waitStatus为-1那么就可以让线程upark进入等待状态（同thread.wait()），那么CLH是如何办到唤醒的呢？答案在release()方法上。但在看后面的release之前，我们注意一个并发问题：
矛盾？一定能唤醒吗？：如果后继节点在把前继节点设置为 SIGNA L后，自己 park() 前，前继就释放了锁来 unpark() 后继怎么办？那么会不会出现后继一直park()呢？其实不会，我们看以下代码就知道了，被unpark后的节点，再次park是不会进入block状态的
/** * Makes available the permit for the given thread, if it * was not already available. If the thread was blocked on * {@code park} then it will unblock. Otherwise, its next call * to {@code park} is guaranteed not to block. This operation * is not guaranteed to have any effect at all if the given * thread has not been started. * * @param thread the thread to unpark, or {@code null}, in which case * this operation has no effect */ public static void unpark(Thread thread) { if (thread != null) U.unpark(thread); }
独占锁释放release(int)：
该方法的目的是用unpark()唤醒等待队列中最前边的那个未放弃线程，问题是所有的线程（不包括头节点线程，因为是它需要释放锁）要么被中断放弃，要么在等待被唤醒，那么该如何唤醒？就是用到waitStatus，首先尝试释放首节点，如果释放失败，那么就从tail开始，一直往前找，如果找到就Node s变量用记下来，找到多个就把最后的覆盖前面的，那么遍历到头节点后，自然s记录的就是最前的需要唤醒的节点了。
假设下面的H代表要放弃锁的head节点，而它需要找到最接近它的等待的节点O并释放该O，算法是先尝试释放H的下一个节点，如果是X，那么就从队列最后开始遍历，用两个指针找到第一个O
H X O O X X O O O O O O X
这里用了两个指针，用一个去遍历，另一个记录有效结果，直到遍历完就知道最合适的是哪个节点了，结合代码就很好看懂：
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);//唤醒 }
从以上代码可以看出，唤醒这个操作是当前线程做的，由获取锁的线程去唤醒下一个线程；这里只需要LocakSupport.unpark，当被唤醒的线程成功后，就会设置自己为head，然后退出代码块，具体见acquireQueue方法注释。
共享获取
这个其实和acquire差不多，只不过获取的status是多个，而且获取失败后直接继续唤醒后调用doAcquireShare
public final void acquireShared(int arg) { if (tryAcquireShared(arg) < 0) doAcquireShared(arg); }
而doAcquireShare方法和acquireQueued方法是差不多的，具体看如下代码注释：
/** * 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 GC if (interrupted) selfInterrupt(); failed = false; return; } } //这里也是找安全点 if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt()) interrupted = true; } } finally { if (failed) cancelAcquire(node); } }
再看看该方法是如何继续唤醒后面线程的，这里注意，唤醒线程有两种情况，第一种是头结点获取到锁后还有资源所以唤醒后面的一起共享，第二种情况是获得锁的线程释放资源的时候去唤醒后面的节点，如下代码所示，doReleaseShared方法就是用作唤醒线程的。
另外，在众多代码中我们都看到interrupted的标记位，可以看出，等待过程是不响应中断的，只会在后期补上中断响应，而中断响应是线程自身决定的。
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(); } }
释放共享
该方法同样简单，尝试释放资源，否则唤醒后面线程，这里我们同样看到了doReleaseShared方法
public final boolean releaseShared(int arg) { if (tryReleaseShared(arg)) {//尝试释放资源 doReleaseShared();//唤醒后继结点 return true; } return false; }
代码：
这里又用到了unparkSuccessor方法，首先判断头结点的waitStates是否为SIGNAL标志，是就设置为0，代表已经不再需要资源，然后自旋（for ;;）调用unparkSusseor，直到后继线程获取成功，后继线程获取成功会被唤醒，唤醒后后继线程第一件事就是在acquireQueue中自旋内部把自己设置为头结点，从而导致head引用（注意，head引用是各个线程共用的）发生变化，这样一来，这个释放的线程节点就能退出循环，代表资源释放完毕。
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; } }
head发生变化，当唤醒成功后，老二结点会自动替换head为自己，所以这里就不再相等，释放成功，请参看appendQueue代码注释、
读写锁 ReadWriteLock
利用state的前16位代表读锁数量，后16位代表写锁数量，利用CAS保证安全
CountDownLatch和CyclicBarrier
他们都是线程同步工具：
- CountDownLatch：首先把AQS的state赋值，CountDownLatch允许一个或者多个线程一直在同步队列中等待，直到state值变为0然后释放等待所有队列中线程
- await通常是主线程等待任务线程countDown
- await是检查state=0？false则加入队列，因为队头会被唤醒和自旋，所以一旦到0会被唤醒所有
- CyclicBarrier：它是当线程到达某种状态后，暂停等待其他线程一起到达该状态，然后一起执行
- CyclicBarrier可以服用，用完后，可以继续await；
- await通常是任务线程在等，多个任务线程等到后执行；
- await是利用ReentrantLock和Condition的，内部维护了一个parties值作为记录个数，count值用作需要await个数，如果count不为0则把线程添加到condition队列，为0则丢到同步队列，操作count值靠ReentrantLock锁；
线程状态转换
另外因为复习该知识点通常要知道一下线程的状态和之间的关系，所以再贴一张图，由此特别说明一下，unpark方法是不加锁进入waiting的唯一方法。
