一：线程等待唤醒的实现方法
二： 介绍一下LockSupport
三：AQS是什么
AQS使用一个volatile的int类型的成员变量来表示同步状态，通过内置的FIFO队列完成资源获取排队工作，将每条要去抢占资源的线程封装成一个NODE节点来实现锁的分配，通过CAS完成对State值的修改，
AQS的本质是一个双向队列加一个状态为state
五：公平锁与非公平锁的区别
公平锁： 多个线程按照线程调用lock()的顺序去获得锁，线程会直接进入队列去排队，永远都是队列的第一位才能得到锁。
非公平锁: 多个线程去获取锁的时候，会直接去尝试获取，获取不到，再去进入等待队列，如果能获取到，就直接获取到锁。
六： 非公平锁加锁的源码分析
tryAcquire(arg)：尝试获取锁
addWaiter(Node.EXCLUSIVE)：添加到同步队列
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))：队列里自旋等待获取等
第一步、tryAquire
先获取当前AQS 的state的值，判断是否为0，如果为0表示没有人抢占，此刻他抢占，返回true，抢占锁后就完事了；
// 这里调用进入非公平锁的tryAcquire
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires);
}
// 具体代码在这里
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
int c = getState();
// 若当前无其他线程抢占锁，则抢占；
if (c == 0) {
if (compareAndSetState(0, acquires)) {
setExclusiveOwnerThread(current);
return true;
}
}
//如果已获取锁的线程再调用lock()则state值+1，这里就是可重入的原理
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
setState(nextc);
return true;
}
// 都不是则返回false
return false;
}
第二步、addWaiter
创建队列的节点，首先就先new出来一个节点，由于当前队列没有节点，因此进入enq()方法；
enq方法插入节点是死循环：
第一次循环，由于tail为空，他先创建一个空的node节点，作为头节点，此时waitStatus=0，然后将head指向该头节点，并将tail指针也指向head；
第二次循环，他将待插入node节点（线程B）的前置指针指向tail指向的节点（头节点），然后CAS将tail指向当前待插入节点（线程B），再让原来的tail指向的节点（头节点）的next域指向当前节点，这样就完成了节点（线程B）插入队尾，完成链式结构，跳出循环；
private Node addWaiter(Node mode) {
// 创建一个节点 mode
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
// 刚开始tail是null，如果tail有值了就将node插入队尾；
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) { // 初始下tail为null，因此创建一个头节点
if (compareAndSetHead(new Node()))
tail = head;
} else {
node.prev = t;// 第二次循环，队列不为空，就将该节点插入队尾
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
第三步：aquireQueued
这个方法依旧是死循环。
第一次循环：首先predecessor()取出的就是前置节点，p就是链表中的头节点，然后进入判断，当前确实是头节点，然后再次尝试tryAcquire()，由于线程A并没有释放锁，因此，只能进入shouldParkAfterFailedAcquire()方法；
第二次循环，再次进入shouldParkAfterFailedAcquire(),这一次由于ws=-1，因此返回true，并进入parkAndCheckInterrupt()方法；这里会调用LockSupport.park()将线程挂起，此刻线程B就阻塞再这里了。
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
for (;;) {
final Node p = node.predecessor();//获取节点的前置节点，线程B获取到的是头节点
if (p == head && tryAcquire(arg)) {//由于线程A占用，尝试获取失败
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())// 线程B会进入这里
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;// 头节点的waitStatus=0
if (ws == Node.SIGNAL)// -1
return true;
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);// 将头节点的waitStatus设置成-1
}
return false;
}
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
