有错误的地方请指教，努力成为一个小菜鸟！
1.简介
countDownLatch是在java1.5被引入的，是java.util.current包下的一个类，简称JUC线程工具类（另外三个类后续介绍），使一个线程等待其他线程各自执行完毕后再执行。
2.原理
内部是通过一个计数器（抽象类AbstractQueuedSynchronizer有个int类型的state变量即计数器）来实现的，计数器的初始值是线程的数量。每当一个线程执行完毕后，计数器的值就-1，当计数器的值为0时，表示所有线程都执行完毕，然后在休眠等待的线程就可以恢复工作了。
3.源码
3.1.构造方法
CountDownLatch(int count)构造一个指定计数的CountDownLatch，count为线程的数量，一旦设置不可修改。当然有的博客说也可以大于线程的数量（暂时还没验证是否会有问题）
该构造方法根据给定count参数构造一个CountDownLatch，内部创建了一个Sync实例。Sync是CountDownLatch的一个内部类，其构造方法代码如下：
public CountDownLatch(int count) {
if (count < 0) throw new IllegalArgumentException("count < 0");
this.sync = new Sync(count);
}
setState方法继承自AQS，给Sync实例的state属性赋值
Sync(int count) {
setState(count);
}
这个state就是CountDownLatch的内部计数器。
protected final void setState(int newState) {
state = newState;
}
3.2.Sync内部类
Sync是CountDownLatch的一个内部类继承AbstractQueuedSynchronizer类简称AQS，后面的await(), countDown()都是通过这个内部类操作AQS这个类。
3.3.await()
比较常用的一个方法，调用此方法的线程进入休眠状态，除非线程被中断。直到计时器为0时，才恢复执行。
public void await() throws InterruptedException {
sync.acquireSharedInterruptibly(1);
}
public final void acquireSharedInterruptibly(int arg)
throws InterruptedException {
//如果当前线程中断，则抛出InterruptedException
if (Thread.interrupted())
throw new InterruptedException();
//尝试获取共享锁，如果可以获取到锁直接返回；
//如果获取不到锁，执行doAcquireSharedInterruptibly
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
//如果当前内部计数器等于零返回1，否则返回-1；
//内部计数器等于零表示可以获取共享锁，否则不可以；
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
//返回内部计数器当前值
protected final int getState() {
return state;
}
//该方法使当前线程一直等待，直到当前线程获取到共享锁或被中断才返回
private void doAcquireSharedInterruptibly(int arg)
throws InterruptedException {
//根据当前线程创建一个共享模式的Node节点
//并把这个节点添加到等待队列的尾部
//AQS等待队列不熟悉的可以查看AQS深入解析的内容
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) {
//将前驱节点从等待队列中释放
//同时使用LockSupport.unpark方法唤醒前驱节点的后继节点中的线程
setHeadAndPropagate(node, r);
p.next = null; // help GC
failed = false;
return;
}
}
//阻塞当前线程
if (shouldParkAfterFailedAcquire(p, node) &&
parkAndCheckInterrupt())
throw new InterruptedException();
}
} finally {
if (failed)
cancelAcquire(node);
}
}
private Node addWaiter(Node mode) {
//根据当前线程创建一个共享模式的Node节点
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方法将节点插入到等待队列尾部
enq(node);
return node;
}
//这里如果不熟悉的可以查看AQS深入解析的内容
Node(Thread thread, Node mode) { // Used by addWaiter
this.nextWaiter = mode;
this.thread = thread;
}
private Node enq(final Node node) {
//使用循环插入尾节点，确保成功插入
for (;;) {
Node t = tail;
//尾节点为空(等待队列是空的)
//新建节点并设置为头结点
if (t == null) { // Must initialize
if (compareAndSetHead(new Node()))
tail = head;
} else {
//否则，将节点插入到等待队列尾部
node.prev = t;
if (compareAndSetTail(t, node)) {
t.next = node;
return t;
}
}
}
}
//获取当前节点的前驱节点
final Node predecessor() throws NullPointerException {
Node p = prev;
if (p == null)
throw new NullPointerException();
else
return p;
}
//判断当前节点里的线程是否需要被阻塞
private static boolean shouldParkAfterFailedAcquire(Node pred, Node node) {
//前驱节点线程的状态
int ws = pred.waitStatus;
//如果前驱节点线程的状态是SIGNAL，返回true，需要阻塞线程
if (ws == Node.SIGNAL)
return true;
//如果前驱节点线程的状态是CANCELLED，则设置当前节点的前去节点为"原前驱节点的前驱节点"
//因为当前节点的前驱节点线程已经被取消了
if (ws > 0) {
do {
node.prev = pred = pred.prev;
} while (pred.waitStatus > 0);
pred.next = node;
} else {
//其它状态的都设置前驱节点为SIGNAL状态
compareAndSetWaitStatus(pred, ws, Node.SIGNAL);
}
return false;
}
//通过使用LockSupport.park阻塞当前线程
//同时返回当前线程是否中断
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
3.4.await(long timeout, TimeUnit unit)
await重载的另一个方法，与上述方法区别可以设置超时等待时间，这个方法我没用过，感觉不太常用。（后面用到的话在进行补充）
3.2.countDown（）
如果计数器到达零，则释放所有等待的线程。如果当前计数大于零，则将计数-1。
public void countDown() {
sync.releaseShared(1);
}
public final boolean releaseShared(int arg) {
//如果内部计数器状态值递减后等于零
if (tryReleaseShared(arg)) {
//唤醒等待队列节点中的线程
doReleaseShared();
return true;
}
return false;
}
//尝试释放共享锁，即将内部计数器值减一
protected boolean tryReleaseShared(int releases) {
for (;;) {
//获取内部计数器状态值
int c = getState();
if (c == 0)
return false;
//计数器减一
int nextc = c-1;
//使用CAS修改state值
if (compareAndSetState(c, nextc))
return nextc == 0;
}
}
private void doReleaseShared() {
for (;;) {
//从头结点开始
Node h = head;
if (h != null && h != tail) {
int ws = h.waitStatus;
if (ws == Node.SIGNAL) {
if (!compareAndSetWaitStatus(h, Node.SIGNAL, 0))
continue;
//唤醒阻塞的线程
unparkSuccessor(h);
}
else if (ws == 0 &&
!compareAndSetWaitStatus(h, 0, Node.PROPAGATE))
continue;
}
if (h == head)
break;
}
}
private void unparkSuccessor(Node node) {
int ws = node.waitStatus;
if (ws < 0)
compareAndSetWaitStatus(node, ws, 0);
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唤醒线程
LockSupport.unpark(s.thread);
}
3.2.getCount()
获取计时器当前的数值，就上述的那个state的值。
4.基本使用demo
4.1场景：双十一秒杀活动，这个活动可以理解为主线程，小明、张三、李四三个人分别为子线程，都准备抢购了。代码如下：
public static void main(String[] args) {
CountDownLatch latch = new CountDownLatch(1);
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
public void run() {
try {
//当前线程阻塞
latch.await();
//多线程中随机数
Thread.sleep(3000+ThreadLocalRandom.current().nextInt(1000));
System.out.println("线程"+Thread.currentThread().getName() + "抢到了！");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}).start();
}
try {
Thread.sleep(5000L);
//所有线程恢复运行
latch.countDown();
System.out.println("5s后秒杀活动开始...");
} catch (InterruptedException e) {
e.printStackTrace();
}
}
运行结果如下：
4.2场景：学校准备考试，监考老师肯定要收完所有卷子才会离开。代码如下：
public static void main(String[] args) {
int size = 5;
CountDownLatch latch = new CountDownLatch(size);
for (int i = 0; i < 5; i++) {
new Thread(new Runnable() {
public void run() {
try {
Thread.sleep(2000+ThreadLocalRandom.current().nextInt(1000));
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("线程"+Thread.currentThread().getName() + "同学卷子交了！");
latch.countDown();
}
}).start();
}
try {
latch.await();
} catch (InterruptedException e) {
e.printStackTrace();
}
System.out.println("所有人都交齐了，监考老师离开教室！");
}
总结
使用CountDownLatch(int count)构建CountDownLatch实例，将count参数赋值给内部计数器state，调用await()方法阻塞当前线程，并将当前线程封装加入到等待队列中，直到state等于零或当前线程被中断；调用countDown()方法使state值减一，如果state等于零则唤醒等待队列中的线程。
扫一扫
284
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
