LOCK
创建时根据参数可设置公平锁或非公平锁，默认非公平锁；
非公平锁流程
进入lock方法：
final void lock() {
//进行一次CAS操作，查看lock的state状态是否为0未加锁状态，是就获取到锁将state改为1;
if (compareAndSetState(0, 1))
//设置当前线程为锁的独占线程
setExclusiveOwnerThread(Thread.currentThread());
else
acquire(1);
}
非公平锁的体现就在这，每个线程来请求锁时，都会先去获取一次锁，如果此时锁被释放，则新来的线程会获取到锁；
进入else步骤的acquire(int arg)方法；
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
方法中会先去尝试获取锁,tryAcquire(int arg)接口的非公平锁实现;
final boolean nonfairTryAcquire(int acquires) {
//获取当前线程
final Thread current = Thread.currentThread();
//获取state的值
int c = getState();
if (c == 0) { //没有线程独占
if (compareAndSetState(0, acquires)) { //CAS设置state的值
//独占锁成功，当前线程为独占线程
setExclusiveOwnerThread(current);
return true;
}
}
//当前线程已经是独占该锁的线程了
else if (current == getExclusiveOwnerThread()) {
int nextc = c + acquires;
if (nextc < 0) // overflow
throw new Error("Maximum lock count exceeded");
//更新state的值，增加重入的次数
setState(nextc);
return true;
}
return false;
}
再次获取锁失败后，第二步时入队；先看addWaiter(Node.EXCLUSIVE)方法；
//将新节点和当前线程关联并且入队列
private Node addWaiter(Node mode) {
//将请求同步状态失败的线程封装成结点
Node node = new Node(Thread.currentThread(), mode);
//获取尾结点引用
Node pred = tail;
//尾结点若不为空，表示队列已经初始化过了
if (pred != null) {
node.prev = pred;
//CAS将新初始化的节点和尾结点进行交换，如果有多个线程包装的节点来进行CAS操作可能出现失败的情况
if (compareAndSetTail(pred, node)) {
pred.next = node;//交换后的尾结点的后置节点赋值，形成双向链表
return node;
}
}
//两种情况：1尾结点为空的情况，需要初始化队列head并将新节点入队
//2、队列已经初始化了，但是CAS替换尾结点的操作失败了
enq(node);
return node;
}
enq方法：
private Node enq(final Node node) {
for (;;) { //死循环（自旋），return跳出
Node t = tail;
if (t == null) { // 对应第一种情况，尾结点为空，需要创建头节点
//创建并使用CAS设置头节点，未跳出循环，会继续进入else
if (compareAndSetHead(new Node()))
tail = head;
} else { //对应第二种情况，CAS替换尾结点失败
node.prev = t;
if (compareAndSetTail(t, node)) {//CAS将尾结点和新节点交换
t.next = node;//设置新的尾结点的后置节点，形成双向链表
return t; //return的值没有意义，仅为了跳出死循环
}
}
}
}
以上可以让没有获取到锁的线程进入AQS的同步队列（FIFO的双向链表队列）。
第三步，挂起，看acquireQueued(addWaiter(Node.EXCLUSIVE), arg)方法；
//node是队列的尾结点，arg为1（state状态，表示同意去争夺锁）
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;//是否成功获取到锁
try {
boolean interrupted = false;//标记线程是否被中断过
for (;;) { //死循环，自旋
//获取尾结点的前驱节点
final Node p = node.predecessor();
//当且仅当前驱节点是头结点的时候在去尝试获取锁，以此来判断头结点是否释放了锁
if (p == head && tryAcquire(arg)) {
//获取锁成功后将node设为头结点，将node的前驱节点置空
setHead(node);
p.next = null; //清除原头结点的next引用 help GC
failed = false;//获取锁成功
return interrupted;//返回中断标志，结束循环
}
//判断挂起线程的情况分两种
//1、当前节点的前驱节点不是头节点
//2、前驱节点是头结点但是头结点没有释放锁
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);//最终都没能获取同步状态，结束该线程的请求
}
}
setHead方法：
//设置为头结点
private void setHead(Node node) {
head = node;
//清空结点数据
node.thread = null;//head中的线程已经获取到了锁，没有必要保存线程了
node.prev = null;
}
shouldParkAfterFailedAcquire(p, node)和 parkAndCheckInterrupt()判断线程是否挂起；
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//获取到前驱节点的等待状态 AQS的每个node节点状态有4种CANCELLED、SIGNAL、CONDITION和PROPAGATE
//CANCELLED（1）表示同步队列中等待的队列超时或者被中断，需要从队列中取消该节点
//SIGNAL(-1) 表示线程处于唤醒状态，只要前驱节点释放了锁就会通知SIGNAL状态的后置节点执行
//CONDITION(-2)等待状态
//PROPAGATE(-3)共享模式的状态
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
*等待状态直接返回
*/
return true;
if (ws > 0) {
/*
* 表示为结束状态，需要遍历前置节点找到不是结束状态的节点
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
/*
* 不是结束状态和唤醒状态的，此处一般是CONDITION状态，CAS将其改为唤醒状态
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
//只有前驱节点是唤醒状态的时候才会挂起当前的节点
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);//挂起线程
return Thread.interrupted(); //返回线程的中断状态
}
acquireQueued(final Node node, int arg)方法中的finally代码：
//将node的状态改为cancelled
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;
//把当前node的状态设置为CANCELLED
node.waitStatus = Node.CANCELLED;
// 如果当前节点是尾节点，将从后往前的第一个非取消状态的节点设置为尾节点
// 更新失败的话，则进入else，如果更新成功，将tail的后继节点设置为null
if (node == tail && compareAndSetTail(node, pred)) {
compareAndSetNext(pred, predNext, null);
} else {
int ws;
// 如果当前节点不是head的后继节点，1:判断当前节点前驱节点的是否为SIGNAL，
2:如果不是，则把前驱节点设置为SINGAL看是否成功
// 如果1和2中有一个为true，再判断当前节点的线程是否为null
// 如果上述条件都满足，把当前节点的前驱节点的后继指针指向当前节点的后继节点
if (pred != head &&
((ws = pred.waitStatus) == Node.SIGNAL ||
(ws <= 0 && compareAndSetWaitStatus(pred, ws, Node.SIGNAL))) &&
pred.thread != null) {
Node next = node.next;
if (next != null && next.waitStatus <= 0)
compareAndSetNext(pred, predNext, next);
} else {
// 如果当前节点是head的后继节点，或者上述条件不满足，那就唤醒当前节点的后继节点
unparkSuccessor(node);
}
node.next = node; // help GC
}
}
当前的流程：
获取当前节点的前驱节点，如果前驱节点的状态是CANCELLED，那就一直往前遍历，找到第一个waitStatus <= 0的节点，将找到的Pred节点和当前Node关联，将当前Node设置为CANCELLED。 根据当前节点的位置，考虑以下三种情况：
(1) 当前节点是尾节点。
(2) 当前节点是Head的后继节点。
(3) 当前节点不是Head的后继节点，也不是尾节点。
unlock
public void unlock() {
sync.release(1);
}
//进入内部方法
public final boolean release(int arg) {
if (tryRelease(arg)) {//先尝试解锁，成功就去查看头结点的waitstatus状态是否为SIGNAL
Node h = head;
if (h != null && h.waitStatus != 0)
//唤醒头结点的后置节点的关联线程
unparkSuccessor(h);
return true;
}
return false;
}
tryRelease(arg)解锁代码：
protected final boolean tryRelease(int releases) {
//计算释放后的state值
int c = getState() - releases;
//不是当前线程占有的锁，抛异常
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) { //state为0即重入次数为0，锁完全释放
free = true;
//清空独占线程
setExclusiveOwnerThread(null);
}
setState(c);
return free;
}
这里入参为1。tryRelease的过程为：当前释放锁的线程若不持有锁，则抛出异常。若持有锁，计算释放后的state值是否为0，若为0表示锁已经被成功释放，并且则清空独占线程，最后更新state值，返回free。
