抽象的队列同步器，是用来构建锁或者其他同步器组件的重量级基础框架及整个JUC体系的基石，通过内置的FIFO队列来完成资源获取线程的排队工作，并通过一个int类型的变量来表示持有锁的状态。
官方说法：
二、与AQS相关联的知识 1、位置 2、ReentrantLock 3、CountDownLatch 4、ReentrantReadWriteLock 5、Semaphore6、锁与同步器的关系
1、锁：面向锁的使用者，定义了程序员和锁交互的使用API，隐藏了实现细节，调用即可。
2、同步器：面向锁的实现者。
三、能干什么 1、AQS主要处理的事情 2、处理原理AQS使用一个volatile的int类型的成员变量来表示同步状态。通过内置的FIFO队列来完成资源获取的排队工作，将每条要去抢占资源的线程封装成一个Node节点来实现锁的分配，通过CAS完成对State值得修改。
3、内部体系架构
1.AQS的int变量
AQS的同步状态State成员变量。默认为0，表示没有线程占用，大于0表示有线程占用
2.AQS的CLH队列
3.Node节点
Node的int变量：Node的等待状态waitState成员变量，队列中等候线程的状态，每个线程就是一个Node节点内部结构
4、总体结构
四、源码解读 一、从ReentrantLock开始解读AQS一、Lock接口的实现类，，基本都是通过聚合一个队列同步器多的子类完成线程访问控制的。
二、ReentrantLock的原理
三、公平锁和非公平锁源码之间的差异
四、ReentrantLock源码加锁方法
1.非公平锁源码
2.acquire()方法：公平锁和非公平锁都有这个方法
3.tryAcquire()方法：公平锁和非公平锁都有，会被acquire方法调用
4.之后执行addWaiter(Node.EXCLUSIVE), arg)这个方法。
private Node addWaiter(Node mode) { Node node = new Node(Thread.currentThread(), mode);//当前线程 // Try the fast path of enq; backup to full enq on failure Node pred = tail; if (pred != null) { node.prev = pred; if (compareAndSetTail(pred, node)) { pred.next = node; return node; } } enq(node);//第一次入队 return node; }
private Node enq(final Node node) { for (;;) { Node t = tail; if (t == null) { // Must initialize if (compareAndSetHead(new Node()))//创建一个新空节点，哨兵节点 tail = head; } else {//第二次才走下面逻辑 node.prev = t; if (compareAndSetTail(t, node)) { t.next = node; return t; } } } }
5.最后执行acquireQueued()方法
shouldParkAfterFailedAcquire方法
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) { //获取前驱节点的状态 int ws = pred.waitStatus; //如果是下面的状态，即等待被占用资源释放，直接返回true，准备继续调用 //parkAndCheckInterrupt() if (ws == Node.SIGNAL) return true; //说明是cancelled状态，即取消状态 if (ws > 0) { do { node.prev = pred = pred.prev; } while (pred.waitStatus > 0); pred.next = node; } else { compareAndSetWaitStatus(pred, ws, Node.SIGNAL); } return false; }
parkAndCheckInterrupt方法
//如果是上一个方法的前驱节点等于-1，就会返回true，然后就会执行这个方法，使线程进入挂起 private final boolean parkAndCheckInterrupt() { LockSupport.park(this); return Thread.interrupted(); }
五、ReentrantLock源码解锁方法
1.unlock()方法
public void unlock() { sync.release(1); }
2.tryRelease(arg)方法
public final boolean release(int arg) { //传入参数为1 if (tryRelease(arg)) { Node h = head; //这个是上一个节点，一般是哨兵节点，所以waitStatus 是-1，除了最后一个是0，前面的都是-1 if (h != null && h.waitStatus != 0) unparkSuccessor(h); return true; } return false; }
protected final boolean tryRelease(int releases) { //state状态位1，主要是有线程占据了位置，releases也为1 int c = getState() - releases; if (Thread.currentThread() != getExclusiveOwnerThread()) throw new IllegalMonitorStateException(); //到了这一步， boolean free = false; if (c == 0) { free = true; //将占用线程置为null，也就是没有线程 setExclusiveOwnerThread(null); } //将状态位置为0 setState(c); return free; }
3.unparkSuccessor(Node node)方法
private void unparkSuccessor(Node node) { //入参是哨兵节点，waitStatus为-1 int ws = node.waitStatus; if (ws < 0) compareAndSetWaitStatus(node, ws, 0); //这个是下一个节点 Node s = node.next; //B节点不为null 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; } //进入这里，解除park状态 if (s != null) LockSupport.unpark(s.thread); }
这个时候后面的线程还在这里转着
private final boolean parkAndCheckInterrupt() { LockSupport.park(this); return Thread.interrupted();//返回false }
之后还进行acquireQueued(final Node node, int arg)方法
final boolean acquireQueued(final Node node, int arg) { boolean failed = true; try { boolean interrupted = false; for (;;) { //node节点是B，获取上一个节点，也就是哨兵节点 final Node p = node.predecessor(); if (p == head && tryAcquire(arg)) { //设置B节点为哨兵节点，里面讲B节点指向哨兵节点的指针置为null setHead(node); //哨兵节点的next指针置为null,垃圾回收器回收掉之前的哨兵节点 p.next = null; // help GC failed = false;//没有走finall哪里的逻辑 return interrupted; } if (shouldParkAfterFailedAcquire(p, node) && parkAndCheckInterrupt())//这个方法执行完继续往下执行，继续循环 interrupted = true; } } finally { if (failed) cancelAcquire(node); } }//这里的入参是1，在前面图片可以看到protected final boolean tryAcquire(int acquires) { return nonfairTryAcquire(acquires); } final boolean nonfairTryAcquire(int acquires) { final Thread current = Thread.currentThread(); //state这个时候已经是0了 int c = getState(); if (c == 0) { // B线程进去占用，也就是将state置为1 if (compareAndSetState(0, acquires)) { setExclusiveOwnerThread(current); return true; } } else if (current == getExclusiveOwnerThread()) { int nextc = c + acquires; if (nextc < 0) // overflow throw new Error("Maximum lock count exceeded"); setState(nextc); return true; } return false; }