一、简介
AQS（AbstractQueuedSynchronizer），抽象队列同步器，是Java中众多的锁以及并发工具的基础，比如ReentrantLock、ReentrantReadWriteLock、CountDownLatch、CyclicBarrier。
AQS有独占锁以及共享锁两种实现，今天，我们来分析AQS获取独占锁的源码。
二、源码分析
先看看继承关系
它继承了AbstractOwnableSynchronizer，实现了序列化的接口。对于AbstractOwnableSynchronizer，主要就是exclusiveOwnerThread这个属性，表示的是当前持有锁的线程，通过它我们可以知道当前占用锁的线程是哪一个。
public abstract class AbstractOwnableSynchronizer
implements java.io.Serializable {
protected AbstractOwnableSynchronizer() { }
private transient Thread exclusiveOwnerThread;
protected final void setExclusiveOwnerThread(Thread thread) {
exclusiveOwnerThread = thread;
}
protected final Thread getExclusiveOwnerThread() {
return exclusiveOwnerThread;
}
}
AQS最主要的属性之一是state，它代表了锁的状态，state为0表示锁没有被占用，state大于0表示锁被占用了，对于独占锁来说，state大于1表示锁重入。
private volatile int state;
AQS还有一个重要的属性是队列的节点，我们来看看节点的结构：
static final class Node {
static final int CANCELLED = 1;
static final int SIGNAL = -1;
static final int CONDITION = -2;
static final int PROPAGATE = -3;
// 线程所处的等待锁的状态，初始化时，该值为0
volatile int waitStatus;
// 双向链表，每个节点需要保存自己的前驱节点和后继节点的引用
volatile Node prev;
volatile Node next;
// 节点所代表的线程
volatile Thread thread;
// 该属性用于条件队列或者共享锁
Node nextWaiter;
}
对于状态变量waitStatus，它表示了当前Node所代表的线程的等待锁的状态，在独占锁模式下，我们主要关注CANCELLED和SIGNAL即可。
对于AQS队列，主要是头尾节点：
private transient volatile Node head;
private transient volatile Node tail;
AQS的队列是一个CLH队列，它的head节点永远是dummy node, 不代表任何线程，因此head所指向的Node的thread属性永远是null，头节点之后的节点代表了在等待锁的线程，如图：
acquire()
话不多说，直接开始分析acquire()方法吧：
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
2.1 tryAcquire(arg)
首先是tryAcquire(arg)，该方法由继承AQS的子类实现, 为获取锁的具体逻辑。我这里以ReentrantLock为例来说明锁的获取流程，它有公平锁 和 非公平锁 两种实现, 默认实现为非公平锁，所以我们来看非公平锁的实现。
public class ReentrantLock implements Lock, java.io.Serializable {
private final Sync sync;
//内部的Sync继承了AQS，Sync有两个子类，如下
abstract static class Sync extends AbstractQueuedSynchronizer {
...
}
// 非公平实现
static final class NonfairSync extends Sync{
...
}
// 公平实现
static final class FairSync extends Sync {
...
}
protected final boolean tryAcquire(int acquires) {
return nonfairTryAcquire(acquires)
}
final boolean nonfairTryAcquire(int acquires) {
final Thread current = Thread.currentThread();
// 获取state的状态
int c = getState();
// state为0，表示锁还没有被线程获取
if (c == 0) {
// 这时候就可以CAS去获取锁
if (compareAndSetState(0, acquires)) {
// CAS成功，把获取锁的线程设为当前线程
setExclusiveOwnerThread(current);
return true;
}
}
// 说明state不0，锁被某个线程获得了
// 因为是可重入锁，所以需要判断获取锁的是不是当前的线程，是的话把状态加acquires
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;
}
我们可以看到，获取锁其实就是通过CAS修改state的值，因此只有一个线程能执行成功。线程成功获取了锁之后，会将exclusiveOwnerThread的值设成自己。
另外对于可重入锁，如果当前线程已经是获取了锁的线程了，它还要注意增加锁的重入次数。
2.2 addWaiter(Node.EXCLUSIVE)
如果前面尝试获取锁的tryAcquire失败了, 那么就要将当前线程包装成Node，加到等待锁的队列中：
private Node addWaiter(Node mode) {
// 首先创建一个Node节点，传入当前的线程以及Node.EXCLUSIVE
Node node = new Node(Thread.currentThread(), mode);
Node pred = tail;
// 如果队列不为空，因为队列是懒加载的，所以可能为空
if (pred != null) {
// 把当前节点的pre节点设置为尾节点
node.prev = pred;
// 然后CAS设置当前节点为尾节点
if (compareAndSetTail(pred, node)) {
// CAS成功就把之前尾节点的next节点设为当前节点
pred.next = node;
return node;
}
}
// 执行到这里, 只有两种情况:
// 1. 队列为空
// 2. 其他线程在当前线程入队的过程中率先入队，导致尾节点的值改变，所以CAS操作失败
enq(node);
return node;
}
首先把线程包装成node，然后尝试直接入队，但是在并发条件下，可能多个线程都在尝试入队，导致compareAndSetTail(pred, node)设置当前节点为尾节点失败，入队失败了，我们就需要调用enq(node)方法，这个方法中其实是通过自旋+CAS的方式，确保当前节点入队。
enq()
private Node enq(final Node node) {
// 死循环，直到入队成功
for (;;) {
Node t = tail;
// 如果空队列，那么进行初始化
if (t == null) { // Must initialize
// 通过CAS创建头节点，因为有多线程并发
if (compareAndSetHead(new Node()))
tail = head;
} else {
// 队列不为空, 继续通过CAS将节点加到队尾
// 如果一直不成功，会一直在循环中重试
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
当队列为空时，新建一个空的头节点，然后进入下一轮循环，在下一轮循环中，队列不为空，就会走加入节点到队列中的逻辑，在循环中一直尝试，直到成功。
当addWaiter(Node.EXCLUSIVE)执行完毕后，节点现在已经被成功添加到队列中，接下来将执行acquireQueued方法。
2.3 acquireQueued()
final boolean acquireQueued(final Node node, int arg) {
boolean failed = true;
try {
boolean interrupted = false;
//
for (;;) {
// 拿到当前节点的前驱节点
final Node p = node.predecessor();
// 如果前驱节点是head节点，说明当前节点是队列中第一个等待锁的节点
// 那么尝试再次获取锁
if (p == head && tryAcquire(arg)) {
// 获取锁成功，把当前节点设为head节点
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
// 到这里要么是获取锁失败，或者队列前面有其它节点在等待锁
// 判断是否需要把当前线程挂起
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}
首先我们获取当前节点的前驱节点，如果前驱节点就是head节点，那说明当前队列中第一个等待锁的节点，所以再试着去获取锁。如果获取成功了，调用setHead方法，将当前节点设置为head节点，
如果p == head && tryAcquire(arg)返回了false，说明要么是获取锁失败，或者队列前面有其它节点在等待锁，此时需要判断是否需要将当前线程挂起，
shouldParkAfterFailedAcquire()
看这块代码之前需要了解waitStatus的状态，它有四种值如下：
static final int CANCELLED = 1;
static final int SIGNAL = -1;
static final int CONDITION = -2;
static final int PROPAGATE = -3;
我们关注的是CANCELLED和SIGNAL ，
CANCELLED表示Node所代表的当前线程已经取消了排队，即放弃获取锁了。
SIGNAL，它有点不一样，不是表征当前节点的状态，而是当前节点的下一个节点的状态。
当一个节点的waitStatus被置为SIGNAL，就说明它的next节点已经被挂起了或者马上就要被挂起了，因此在当前节点释放了锁或者放弃获取锁时，如果它的waitStatus属性为SIGNAL，它要去唤醒它的后继节点。
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
// 获得前驱节点的ws
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
// 前驱节点的状态已经是SIGNAL了，返回true，待会可以挂起了
return true;
if (ws > 0) {
// ws > 0, 说明是CANCELLED，前驱节点已经取消了等待锁
// 那就继续往前找, 直到找到一个还在等待锁的节点
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
// 然后可以略过这些取消等待锁的节点, 排在刚才找到的等待锁的节点的后面
pred.next = node;
} else {
// 前驱节点的状态既不是SIGNAL，也不是CANCELLED
// 那么就CAS设置前驱节点的ws为 Node.SIGNAL，让它到时候来唤醒自己
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
- 如果为前驱节点的waitStatus值为SIGNAL ，返回 true，可以挂起当前节点了
- 如果为前驱节点的waitStatus值为CANCELLED, 略过这些节点, 直到找到正常等待中的前驱节点，然后排在它后面，返回false
- 前驱节点的状态既不是SIGNAL，也不是CANCELLED, 直接将前驱节点的状态改为SIGNAL, 返回false
返回false的话其实是走acquireQueued()的循环，这是因为此时我们的前驱节点可能已经变了，比如前驱节点就变成head节点，那么还需要再次尝试获取锁；
当shouldParkAfterFailedAcquire返回true，也就是当前节点的前驱节点的waitStatus状态已经是SIGNAL，此时我们将调用parkAndCheckInterrupt挂起线程；
parkAndCheckInterrupt()
private final boolean parkAndCheckInterrupt() {
// 利用LockSupport挂起线程
LockSupport.park(this);
// 如果线程是被中断唤醒的，返回true，同时中断标志位会被清空，
return Thread.interrupted();
}
很简单，就利用LockSupport挂起线程，等待被唤醒，有两种情况会被唤醒
- 获得锁的线程在释放锁的时候，会调用release()方法，这个方法会调用LockSupport.unpark()唤醒挂起线程；被唤醒后，在acquireQueued()循环尝试获取锁。
- 当前线程被中断了，那么也会唤醒，唤醒后调用Thread.interrupted()方法返回true，同时中断标志位会被清空，不过在外层会把interrupted 设为 true。
三：总结
AQS中用state属性表示锁，如果通过CAS操作成功将state属性从0设置成1即获取了锁，
获取了锁的线程会将exclusiveOwnerThread设置成自己，如果获取锁失败，addWaite()方法把当前线程包装成Node,并添加到队列的末尾，在Node成功队列的末尾后，会调用acquireQueued方法，首先根据Node的前驱节点是不是head选择要不要尝试获取锁，不是的话就需要调用shouldParkAfterFailedAcquire方法，它会一直往前找前驱节点，直到会保证当前线程的前驱节点的waitStatus属性值为SIGNAL,这样的话，在自己挂起后，前驱节点会在合适的时候唤醒自己（释放锁以及放弃等待锁的时候），最后parkAndCheckInterrupt方法用于挂起当前线程，并检查中断状态。
232
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
