AQS API
节点的状态
下面我们借助上面的API图阅读源码
独占模式获取锁acquire，忽略中断
public final void acquire(int arg) {
// 尝试获取锁，如果获取不成功，则加入到CLH队列等待，并且中断当前线程
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
protected boolean tryAcquire(int arg) {
throw new UnsupportedOperationException();
}
private Node addWaiter(Node mode) {
// 用当前线程创建一个Node，mode=Node.EXCLUSIVE也就是null（独占锁的nextWaiter是null）
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
// 如果CLH队尾是空的，或者CAS把新节点更新成尾结点失败了，则调用完整入队方法enq
// 否则快速入队
Node pred = tail;
if (pred != null) {
// 新节点的前置结点指向pred（原队尾结点）
node.prev = pred;
// 将tail更新成新节点node，但是不会影响局部变量pred，pred还是原队尾结点
if (compareAndSetTail(pred, node)) {
// 原队尾结点.next指向新节点
pred.next = node;
return node;
}
}
// 完整入队
enq(node);
return node;
}
addWaiter
tryAcquire是需要子类必须重写的方法，如果不重写就会抛出UnsupportedOperationException
独占模式获取锁acquire，响应中断
public final void acquireInterruptibly(int arg)
throws InterruptedException {
// 当前线程被中断，抛出InterruptedException
if (Thread.interrupted())
throw new InterruptedException();
// 如果尝试获取锁失败，那么在可中断模式下获取锁
if (!tryAcquire(arg))
doAcquireInterruptibly(arg);
}
/**
* Acquires in exclusive interruptible mode.
* @param arg the acquire argument
*/
private void doAcquireInterruptibly(int arg)
throws InterruptedException {
// 创建一个和当前线程绑定Node，并加入队尾
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
// 获取node的前置节点
final Node p = node.predecessor();
// 如果node的前置节点就是头节点了，那么应该拿到资源的线程应该是当前线程，也就是新创建的node
if (p == head && tryAcquire(arg)) {
// 拿到资源后把node设置为head节点，因为这个node拿到资源了，要轮到下一个node了
setHead(node);
// 把原head节点删除
p.next = null; // help GC
failed = false;
return;
}
// 如果拿锁失败，并且需要挂起，那么需要挂起当前线程，并设置中断状态
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
// 没拿到锁取消当前节点拿锁请求
if (failed)
cancelAcquire(node);
}
}
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
// 如果前一个节点的状态是SIGNAL，返回true，可以将当前线程挂起
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
// 如果如果前一个节点的状态是CANCELLED，那么循环向前查找取消节点，把取消节点从队列中删除
if (ws > 0) {
/*
* Predecessor was cancelled. Skip over predecessors and
* indicate retry.
*/
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
// 如果是其他状态，那么将前置节点的waitStatus设置成SIGNAL
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
Q：在shouldParkAfterFailedAcquire中为什么前置节点的状态是SIGNAL了，还要挂起当前线程？
A：节点状态是SIGNAL表示当前节点如果释放锁，可以通知唤醒后面的节点了。当获取锁失败的时候，如果前置节点状态是SIGNAL就表明，可以安全的挂起当前线程，因为前置节点一旦释放锁，会通知唤醒后面的节点。
Q：HEAD节点是干嘛的，为什要有它？
A：HEAD节点表示已经获取到锁的节点（doAcquireInterruptibly方法，setHead），前面说了，SIGNAL表示当前节点如果释放锁，可以通知唤醒后面的节点了。所以所有的线程在休眠之前都要，把前置节点的状态设置成SIGNAL，否则自己永远无法被唤醒。那么第一个节点没有前置节点怎么办呢，那就加一个HEAD。
独占模式获取锁tryAcquireNanos(int arg, long nanosTimeout)，响应中断并且带有超时时间
public final boolean tryAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
// 如果当前线程被中断那么抛出InterruptedException
if (Thread.interrupted())
throw new InterruptedException();
// 直接获取锁，若获取不成功，就进入到带有超时时间的获取锁方法doAcquireNanos
return tryAcquire(arg) ||
doAcquireNanos(arg, nanosTimeout);
}
private boolean doAcquireNanos(int arg, long nanosTimeout)
throws InterruptedException {
// 边界检查
if (nanosTimeout <= 0L)
return false;
// 当前时间+超时时间=过期时间
final long deadline = System.nanoTime() + nanosTimeout;
// 新加一个节点
final Node node = addWaiter(Node.EXCLUSIVE);
boolean failed = true;
try {
for (;;) {
// 若前置节点是head，说明当前线程可以获取锁了，获取锁成功后，释放原head节点
// 并且将新加的节点node设置为head
final Node p = node.predecessor();
if (p == head && tryAcquire(arg)) {
setHead(node);
p.next = null; // help GC
failed = false;
return true;
}
// 循环拿锁中超时检查，若超时返回false
nanosTimeout = deadline - System.nanoTime();
if (nanosTimeout <= 0L)
return false;
// 如果当前节点可以被挂起，并且还剩余的时间大于超时时间的阈值1000L的话，挂起当前线程nanosTimeout纳秒
if (shouldParkAfterFailedAcquire(p, node) &&
nanosTimeout > spinForTimeoutThreshold)
LockSupport.parkNanos(this, nanosTimeout);
// 如果当前线程被中断了，那么抛出InterruptedException
if (Thread.interrupted())
throw new InterruptedException();
}
} finally {
// 没获取到锁，取消节点拿锁请求
if (failed)
cancelAcquire(node);
}
}
Q：为何循坏拿锁的时候，如果当前节点可以被挂起，并且还剩余的时间大于超时时间的阈值1000L的话，挂起当前线程nanosTimeout纳秒？
A：为了提高响应能力，如果不挂起当前线程的话，在这剩余的超时时间里会占用资源一直循环拿锁，直到超时或者线程被中断为止。挂起当前线程nanosTimeout纳秒，在这期间可以让别的线程先去占资源。
