在JDK的并发包里(java.util.concurrent)提供了这样几个非常有用的并发工具类来解决并发编程的流程控制。分别是CountDownLatch、CyclicBarrier和Semaphore。
1、CountDownLatch是什么?
CountDownLatch类位于java.util.concurrent包下,利用它可以实现类似计数器的功能。CountDownLatch大多是被用在等待多线程完成,具体来说就是允许一个或多个线程等待其他线程完成操作。比如有一个任务A,它要等待其他4个任务执行完毕之后才能执行,此时就可以利用CountDownLatch来实现这种功能了。
2、CountDownLatch原理
CountDownLatch类只提供了一个构造器:
public void CountDownLatch(int count) {...}
在 CountDownLunch启动的时候。主线程必须在启动其他线程后立即调用CountDownLatch.await()方法。这样主线程的操作就会在这个方法上阻塞,直到其他线程完成各自的任务。在每次任务执行完直接调用,计数器就会减一操作。
//调用await()方法的线程会被挂起,它会等待直到count值为0才继续执行
public void await() throws InterruptedException { };
//和await()类似,只不过等待一定的时间后count值还没变为0的话就会继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };
//将count值减1
public void countDown() { };
await()这个方法就是用来堵塞主线程的,前者是有等待时间的,可以自定义,后者是无限等待,直到其他count 计数器为0为止。
3、使用场景
- 超时机制
主线程里面设置好等待时间,如果发现在规定时间内还是没有返回结果,那就唤醒主线程,抛弃。 - 开始执行前等待n个线程完成各自任务
例如应用程序启动类要确保在处理用户请求前,所有N个外部系统已经启动和运行了。 - 死锁检测
一个非常方便的使用场景是,你可以使用n个线程访问共享资源,在每次测试阶段的线程数目是不同的,并尝试产生死锁。
4、深入源码
CountDownLunch 源码底层是由AbstractQueuedSynchronizer提供支持(后面就简称 AQS),所以其数据结构就是AQS的数据结构,而AQS的核心就是两个虚拟队列:同步队列syncQueue 和条件队列conditionQueue(前者数据结构是双向链表,后者是单向链表)不同的条件会有不同的条件队列。
- Sync源码
private static final class Sync extends AbstractQueuedSynchronizer {
// 版本号
private static final long serialVersionUID = 4982264981922014374L;
// 构造器
Sync(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;
}
}
}
- await函数
此函数将会使当前线程在锁存器倒计数至零之前一直等待,除非线程被中断。其源码如下:
public void await() throws InterruptedException{
// 转发到sync对象上
sync.acquireSharedInterruptibly(1);
}
源码可知,对CountDownLatch对象的await的调用会转发为对Sync的acquireSharedInterruptibly(从AQS继承的方法)方法的调用。
public final void acquireSharedInterruptibly(int arg) throws InterruptedException {
if (Thread.interrupted())
throw new InterruptedException();
if (tryAcquireShared(arg) < 0)
doAcquireSharedInterruptibly(arg);
}
这里先检测了线程中断状态,中断了则抛出异常,接下来调用tryAcquireShared,tryAcquireShared是Syn的实现的。
protected int tryAcquireShared(int acquires) {
return (getState() == 0) ? 1 : -1;
}
其实就是简单的获取了同步器的state,判断是否为0。
接下来是
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);
}
}
关键点是parkAndCheckInterrupt()
private final boolean parkAndCheckInterrupt() {
LockSupport.park(this);
return Thread.interrupted();
}
执行到此处时,线程会阻塞,知道有其他线程唤醒此线程,执行await之后,上文中的主线程阻塞在这。
- countDown函数
此函数将递减锁存器的计数,如果计数到达零,则释放所有等待的线程
void countDown() {
sync.releaseShared(1);
}
可以看出 对countDown的调用转换为对Sync对象的releaseShared(从AQS继承而来)方法的调用。
5、使用
/**
* 对一个文本中的所有数字先行求和,再把所有行汇总
* */
public class Demo2 {
private int[] nums; //存储每一行求和数
public Demo2(int line) {
nums = new int[line];
}
//行求和
public void calc(String line, int index,CountDownLatch latch) {
String[] nus = line.split(","); // 切分出每个值
int total = 0;
for (String num : nus) {
total += Integer.parseInt(num);
}
nums[index] = total; // 把计算的结果放到数组中指定的位置
System.out.println(Thread.currentThread().getName() + " 执行计算任务... " + line + " 结果为:" + total);
latch.countDown();//CountDownLatch计数器减1
}
//行汇总
public void sum() {
System.out.println(Thread.currentThread().getName()+"汇总线程开始执行... ");
int total = 0;
for (int i = 0; i < nums.length; i++) {
total += nums[i];
}
System.out.println("最终的结果为:" + total);
}
//读取文本数据
private static List<String> readFile() {
List<String> contents = new ArrayList<>();
String line = null;
BufferedReader br = null;
try {
br = new BufferedReader(new FileReader("/Users/Amy/Downloads/nums.txt"));
while ((line = br.readLine()) != null) {
contents.add(line);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
if (br != null) {
try {
br.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return contents;
}
public static void main(String[] args) {
List<String> contents = readFile();//读取文本数据
int lineCount = contents.size();//行数
CountDownLatch latch = new CountDownLatch(lineCount);
Demo2 d = new Demo2(lineCount);
for (int i = 0; i < lineCount; i++) {
final int j = i;
new Thread(new Runnable() {
@Override
public void run() {
d.calc(contents.get(j), j,latch);//行求和
}
}).start();
}
try {
latch.await();//等待所有线程将行求和全部进行完毕
} catch (InterruptedException e) {
e.printStackTrace();
}
d.sum();//汇总求和
}
}