Java中最常用的锁ReentrantLock就是基于AQS来实现的。网上已经有很多的资料来讲解AQS的原理。因此这里只是写一下个人比较难以理解的点，用以学习。
这里贴一篇非常好的AQS的文章，讲的非常详细，看完了还是可以学到很多东西。
从ReentrantLock的实现看AQS的原理及应用 - 美团技术团队 (meituan.com)
这里就记录下ReentrantLock的非公平锁。
首先是acquire(int)函数，当tryAcquire函数获取锁失败后，将会把线程加入等待队列。
java
public final void acquire(int arg) {
if (!tryAcquire(arg) && acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}关键就在于这个acquireQueued函数，addWaiter()函数就是新建一个节点，然后将节点放入等待队列的末尾，上面放的那篇文章已经非常详细，这里就不写了。
接下来看看acquireQueued()函数。
java
/**
* Acquires in exclusive uninterruptible mode for thread already in
* queue. Used by condition wait methods as well as acquire.
*
* @param node the node
* @param arg the acquire argument
* @return {@code true} if interrupted while waiting
*/
@ReservedStackAccess
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)) {
setHead(node);
p.next = null; // help GC
failed = false;
return interrupted;
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
interrupted = true;
}
} finally {
if (failed)
cancelAcquire(node);
}
}这里可以看到进入函数之后，会进入自旋，首先找到前驱节点，如果前驱节点已经是head虚节点了，即当前线程可以获得锁，则调用tryAcquire()函数尝试获取锁。获取成功则将当前节点设置为虚节点，然后退出自旋，返回线程是否被中断。
如果前驱节点不是head，那么将会进入shouldParkAfterFailedAcquire()函数，该函数用于判断线程是否应该被阻塞。
java
/**
* Checks and updates status for a node that failed to acquire.
* Returns true if thread should block. This is the main signal
* control in all acquire loops. Requires that pred == node.prev.
*
* @param pred node's predecessor holding status
* @param node the node
* @return {@code true} if thread should block
*/
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
int ws = pred.waitStatus;
if (ws == Node.SIGNAL)
/*
* This node has already set status asking a release
* to signal it, so it can safely park.
*/
return true;
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 must be 0 or PROPAGATE. Indicate that we
* need a signal, but don't park yet. Caller will need to
* retry to make sure it cannot acquire before parking.
*/
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}进入后先检测前驱节点的状态ws。
下面是waitStatus的常量
java
/** Marker to indicate a node is waiting in exclusive mode */
static final Node EXCLUSIVE = null;
/** waitStatus value to indicate thread has cancelled */
static final int CANCELLED = 1;
/** waitStatus value to indicate successor's thread needs unparking */
static final int SIGNAL = -1;
/** waitStatus value to indicate thread is waiting on condition */
static final int CONDITION = -2;
/**
* waitStatus value to indicate the next acquireShared should
* unconditionally propagate
*/
static final int PROPAGATE = -3;-
当前驱节点已经是唤醒状态，也就是Node.SIGNAL的情况下，当前线程就可以直接阻塞，返回true。
-
如果ws大于0，即前驱节点为取消状态，那么就进入do-while循环，不断寻找前驱节点，直到找到一个不是取消状态的节点。然后将不是取消状态的节点的next直接指向当前节点（也就是直接跳过中间被取消的节点）。
-
否则代表其他状态，则通过cas尝试将状态设置为SIGNAL。
当返回true以后，将会调用parkAndCheckInterrupt()函数，这里进入后会调用unsafe的park方法，将线程阻塞。
java
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
// LockSupport.java
public static void park(Object blocker) {
Thread t = Thread.currentThread();
setBlocker(t, blocker);
UNSAFE.park(false, 0L);
setBlocker(t, null);
}这里将会设置阻塞对象parkBlocker，这是一个Thread类的私有成员。
java
private static void setBlocker(Thread t, Object arg) {
// Even though volatile, hotspot doesn't need a write barrier here.
UNSAFE.putObject(t, parkBlockerOffset, arg);
}设置完成后就调用UNSAFE.park()阻塞线程。
这里的parkBlocker是用来记录线程是被哪个对象阻塞的，用于线程监控和分析，通过LockSupport.getBlocker()函数就可以获取parkBlocker。