前言:作为一个合格的程序猿,我想不用我说,大家心里都应该知道,阅读源码的重要性吧!也许你会想,我只能能实现一个功能或者满足产品的需求不就万事大吉了吗?我为什么要去关注java底层的源码或者第三方工具包的实现呢? 这个为什么,我就不多说了,想要在学习和工作中能够得到质的提升,这个过程我认为是避不开的。
好了,开始我的源码之旅吧!我也是最近才开始想到写一些关于技术的博文,希望能帮助到需要的人,有任何不对的地方请指正。
先定义一个闭锁:
CountDownLatch latch = new CountDownLatch(2);
1,查看一下CountDownLatch构造函数:
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
2,构造方法里调用一个内部类 Sync
private static final class Sync extends AbstractQueuedSynchronizer {
private static final long serialVersionUID = 4982264981922014374L;
//内部类构造方法,设置state个数,表示可以获取锁的个数
Sync(int count) {
//调用AQS的setStats(int count)来设置状态位
setState(count);
}
int getCount() {
return getState();
}
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
int c = getState();
if (c == 0)
return false;
int nextc = c-1;
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
}
3,分析一下
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
if (tryReleaseShared(arg)) {
//如果返回true,表明state==0,此时可以释放所有等待色线程节点
doReleaseShared();
return true;
}
return false;
}
protected boolean tryReleaseShared(int releases) {
// Decrement count; signal when transition to zero
for (;;) {
//自旋判断state状态
int c = getState();
//做自减之前如果state已经为0 ,返回false
if (c == 0)
return false;
int nextc = c-1;
//CAS 做自减操作
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
4,释放等待的线程节点
private void doReleaseShared() {
/*
* Ensure that a release propagates, even if there are other
* in-progress acquires/releases. This proceeds in the usual
* way of trying to unparkSuccessor of head if it needs
* signal. But if it does not, status is set to PROPAGATE to
* ensure that upon release, propagation continues.
* Additionally, we must loop in case a new node is added
* while we are doing this. Also, unlike other uses of
* unparkSuccessor, we need to know if CAS to reset status
* fails, if so rechecking.
*/
for (;;) {
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue; // loop to recheck cases
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue; // loop on failed CAS
}
if (h == head) // loop if head changed
break;
}
}
5,分析await()方法
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
/*
具体如下:
1、检测中断标志位
2、调用tryAcquireShared方法来检查AQS标志位state是否等于0,如果state等于0,则说明不需要等待,立即返回,否则进行3
3、调用doAcquireSharedInterruptibly方法进入AQS同步队列进行等待,并不断的自旋检测是否需要唤醒
*/
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
/*
函数功能:根据AQS的状态位state来返回值,
如果为state=0,返回 1
如果state=1,则返回-1
*/
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
/**
* Acquires in shared interruptible mode.
* @param arg the acquire argument
*/
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
final Node node = addWaiter(Node.SHARED);
boolean failed = true;
try {
for (;;) {
final Node p = node.predecessor();
if (p == head) {
int r = tryAcquireShared(arg);
if (r >= 0) {//如果大于零,则说明需要唤醒
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}