二十七、并发编程之并发工具类CountDownLatch详解

在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();//汇总求和
	}
}