一、概述
Java并发编程核心在于java.concurrent.util包，而juc当中的大多数同步器实现都是围绕着共同的基础行为，比如等待队列、条件队列、独占获取、共享获取等，而这个行为的抽象就是基于AbstractQueuedSynchronizer简称AQS，AQS是定义了一套多线程访问共享资源的同步器框架，是一个依赖状态(state)的同步器。
AQS具备特性：阻塞等待队列、共享/独占、公平/非公平、可重入、允许中断。
注意：像ReentrantLock、Semaphore、Barrier等等框架都有一个内部类Sync同步器，Sync继承了AQS框架。
注意：等待队列、条件队列让JUC有了公平锁和非公平锁；独占获取、共享获取让让JUC有了独占锁（排他锁）和共享锁；状态(state)让JUC有了重入锁。
应用
AQS内部维护属性volatile int state (32位)，state表示资源的可用状态；内部定义两种队列：同步等待队列、条件等待队列；内部类Sync继承AQS，AQS所有调用都映射到Sync对应的方法。
State三种访问方式
getState()、setState()、compareAndSetState()
AQS定义两种资源共享方式
Exclusive-独占：只有一个线程能执行，如ReentrantLock。
Share-共享：多个线程可以同时执行，如Semaphore/CountDownLatch。
二、ReentrantLock
ReentrantLock是基于AQS实现的独占锁，如下图，有内部类Sync，Sync继承AQS框架，关键变量state记录上锁次数；exclusiveOwnerThread记录当前占有锁的线程；CLH变种队列BlockingQueue（双向链表阻塞队列）也是同步队列存储正在等待的线程。
注意：原生的CLH队列里面的线程是自旋的，不会丢掉CPU的使用权。CLH队列变种是基于原生的修改，里面线程处于阻塞状态。
CLH队列的是由AQS框架中的Node对象构建成的双向链表，Node对象有以下重要属性：
static final Node SHARED：标志以共享节点入队列。
static final Node EXCLUSIVE：标志以独占节点入队列。
static final int CANCELLED：标志线程中断状态。
static final int SIGNAL：标志线程可唤醒。
static final int CONDITION：标志Node为条件队列。
static final int PROPAGATE：标志线程唤醒可传播，共享模式下使用。
volatile int waitStatus：CANCELLED、SIGNAL、CONDITION、PROPAGATE信号量。
volatile Thread thread：线程。
volatile Node prev：前驱节点，使用在CLH同步队列中。
volatile Node next：后继节点，使用在CLH同步队列中。
Node nextWaiter：后继节点，使用在条件队列中。
注意1：若为条件队列，那么Node必须为EXCLUSIVE独占模式，不能是共享模式。
注意2：CLH同步队列为双向链表，条件队列为单向链表。
应用
ReentrantLock lock = new ReentrantLock(boolean flag)；
true：创建公平锁，CLH队列不为空，新来的线程直接进入队列等待。
false：创建非公平锁，CLH队列不为空，新来的线程直接去争抢锁，争抢不到再去队列等待。
争抢锁过程如上图，若线程抢锁成功，会以CAS方式修改AQS框架中volatile int state的值，然后修改exclusiveOwnerThread指向当前线程；若线程抢锁失败，创建一个EXCLUSIVE Node，然后以CAS方式添加到CLH队列尾部进行阻塞，其中CAS原理是基于java unsafe魔术类来实现的，AQS线程阻塞也是java unsafe实现，阻塞和解锁分别是unsafe.park()与unsafe.unpark()。
线程执行完毕，也会以CAS方式修改volatile int state，然后修改设置exclusiveOwnerThread为空，最后去唤醒队列中的第一个线程节点，与notify和notifyAll不同，不会随机唤醒一个线程和唤醒所有的线程节点。
总结：AQS中，涉及大量的死循环配合CAS和volatile进行操作，大量的并发会触使CAS和volatile操作失败，只有CAS操作返回true才能跳出循环。
三、Semaphore
Semaphore 字面意思是信号量的意思，它的作用是控制访问特定资源的线程数目。Semaphore 在AQS中，属于共享锁，使用场景：资源访问，服务限流。
如上图，在ReentrantLock中volatile int state为独占锁独占的标志，但在Semaphore中state为共享锁的资源总数。
应用
Semaphore 属于共享锁，默认创建非公平锁。调用Semaphore构造方法可以创建一个共享锁。
构造方法
public Semaphore(int permits)
public Semaphore(int permits, boolean fair)
其中permits 表示许可线程的数量，fair 表示公平性，默认为false，如果这个设为 true 的话，下次执行的线程会是等待最久的线程。
主要方法
public void acquire() throws InterruptedException
public void release()
tryAcquire（long timeout, TimeUnit unit）
acquire() 表示阻塞并获取许可，volatile int state CAS操作减1。
release() 表示释放许可，volatile int state CAS操作加1。
Semaphore semaphore = new Semaphore(5);
for(int i = 0; i<10; i++){
new Thread(new Task(semaphore,"lin"+i)).start();
}
//Task类的run方法
public void run() {
try
{
semaphore.acquire();
Thread.sleep(5000);
System.out.println(Thread.currentThread().getName() + "处理结束...");
}
catch (Exception ex)
{
System.out.println(ex.getMessage());
}
finally {
semaphore.release();
}
}
四、CountDownLatch
CountDownLatch这个类能够使一个线程等待其他线程完成各自的工作后再执行。例如，应用程序的主线程希望在负责启动框架服务的线程已经启动所有的框架服务之后再执行。
CountDownLatch是通过一个计数器来实现的，计数器的初始值为线程的数量。每当一个线程完成了自己的任务后，计数器的值就会减1。当计数器值到达0时，它表示所有的线程已经完成了任务，然后在闭锁上等待的线程就可以恢复执行任务。
应用
CountDownLatch属于共享锁，由主线程把任务分配给多个其它的线程进行执行，其它的线程执行完毕后，再回到主线程这边来，这里的任务可以是不同类型的。
构造方法
public CountDownLatch(int count)
count为任务的数量。
主要方法
CountDownLatch.countDown()；
CountDownLatch.await()；
countDown()：volatile int state CAS操作减1。
await()：主线程汇总等待。
static CountDownLatch countDownLatchLock = new CountDownLatch(2);
//主线程
public static void main(String[] args) throws InterruptedException {
new SeeDoctorThread().start();
new QueueGetMedThread().start();
countDownLatchLock.await();
//最后集合汇总，一起回家
System.out.println("男生女生门口集合，开车一起回家");
}
// 分工合作，不分先后
/**
* 女生上厕所线程
*/
static class SeeDoctorThread extends Thread
{
@Override
public void run() {
try {
Thread.sleep(7*1000);
System.out.println("女生上完厕所！");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
countDownLatchLock.countDown();
}
}
}
/**
* 男生上厕所线程
*/
static class QueueGetMedThread extends Thread
{
@Override
public void run() {
try {
Thread.sleep(3*1000);
System.out.println("男生上完厕所！");
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
countDownLatchLock.countDown();
}
}
}
注意：CountDownLatch 的使用是一次性的，用完即止，不可重复使用。
五、CyclicBarrier
栅栏屏障，让一组线程到达一个屏障（也可以叫同步点）时被阻塞，直到最后一个线程到达屏障时，屏障才会开门，所有被屏障拦截的线程才会继续运行。CyclicBarrier默认的构造方法是CyclicBarrier（int parties），其参数表示屏障拦截的线程数量，每个线程调用await方法告CyclicBarrier我已经到达了屏障，然后当前线程被阻塞。
应用
CyclicBarrier属于共享锁，任务分配给多个其它的线程进行执行，其它的线程执行完毕后，再回到主线程这边来，这里的任务可以是不同类型的。
构造方法
public CyclicBarrier(int parties, Runnable barrierAction)
parties为任务的数量。
主要方法
cyclicBarrier.await()
等待其它线程。
//游戏五人开黑
static CyclicBarrier barrierLock = new CyclicBarrier(5, new Runnable() {
@Override
public void run() {
System.out.println("开始游戏...");
}
});
public static void main(String[] args) throws InterruptedException {
//4台顶级配置电脑 1台普通配置电脑
for(int i = 0; i < 4; i++)
{
new LoadingGameThread_1().start();
}
new LoadingGameThread_2().start();
}
/**
* 玩家顶级配置电脑进入游戏线程
*/
static class LoadingGameThread_1 extends Thread
{
@Override
public void run() {
try {
Thread.sleep(2*1000);
System.out.println("顶级配置电脑进入游戏成功...");
barrierLock.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}
/**
* 玩家普通配置电脑进入游戏线程
*/
static class LoadingGameThread_2 extends Thread
{
@Override
public void run() {
try {
Thread.sleep(5*1000);
System.out.println("普通配置电脑进入游戏成功...");
barrierLock.await();
} catch (InterruptedException | BrokenBarrierException e) {
e.printStackTrace();
}
}
}
注意：CyclicBarrier跟CountDownLatch在于它是可以重复使用的，还有个区别是CyclicBarrier不需要汇总。