1、CountDownLatch、ReentrantLock等并发包中的同步底层实现都是用的AQS:AbstractQueueSynchronizer
2、AQS包含资源state数字,阻塞的时候说明state不等于0
3、获取到锁,将state+1,释放锁的时候-1,当state等于0说明可以获取到锁
4、CountDownLatch初始化将state设置为N,主线程调用await方法阻塞,也就是判断state是否为0,此时说明有N个线程同时执行,每个线程执行完countDown一次,当state减为0的时候,await方法可继续执行。
5、AQS通过CAS修改state的值,CompareAndSwap,调用了C语言的Unsafe类的cas方法。
//直接获取锁,获取失败进入队列FIFO
public final void acquire(int arg) {
if (!tryAcquire(arg) &&
acquireQueued(addWaiter(Node.EXCLUSIVE), arg))
selfInterrupt();
}
//进入链表尾部
private Node addWaiter(Node mode) {
Node node = new Node(Thread.currentThread(), mode);
// Try the fast path of enq; backup to full enq on failure
Node pred = tail;
if (pred != null) {
node.prev = pred;
if (compareAndSetTail(pred, node)) {
pred.next = node;
return node;
}
}
enq(node);
return node;
}
//释放锁
public final boolean release(int arg) {
if (tryRelease(arg)) {
Node h = head;
if (h != null && h.waitStatus != 0)
unparkSuccessor(h);
return true;
}
return false;
}
//tryRelease需要自己实现,AQS没有提供实现类,排他锁和共享锁不一样,下面以ReentrantLock排他锁为例
protected final boolean tryRelease(int releases) {
int c = getState() - releases;
if (Thread.currentThread() != getExclusiveOwnerThread())
throw new IllegalMonitorStateException();
boolean free = false;
if (c == 0) {
free = true;
setExclusiveOwnerThread(null); //将排他锁占有者设为空
}
setState(c);
return free;
}
private void unparkSuccessor(Node node) {
/*
* If status is negative (i.e., possibly needing signal) try
* to clear in anticipation of signalling. It is OK if this
* fails or if status is changed by waiting thread.
*/
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
/*
* Thread to unpark is held in successor, which is normally
* just the next node. But if cancelled or apparently null,
* traverse backwards from tail to find the actual
* non-cancelled successor.
*/
Node s = node.next;
if (s == null || s.waitStatus > 0) {
s = null;
for (Node t = tail; t != null && t != node; t = t.prev)
if (t.waitStatus <= 0)
s = t;
}
if (s != null)
LockSupport.unpark(s.thread); //唤醒线程
}
//当头部线程释放锁后,唤醒后续线程
public static void unpark(Thread thread) {
if (thread != null)
UNSAFE.unpark(thread); //C语言底层调用唤醒线程
}
//共享锁,以CountDownLatch的实现为例,可以多个线程调用await方法,共享这个锁
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}