CountDownLatch、join 与 CyclicBarrier

java中的并发工具类：

1、CountDownLatch:
CountDownLatch允许一个或多个线程等待其他线程完成操作。
假如有这样一个需求：我们需要解析一个Excel里多个sheet的数 据，此时可以考虑使用多线程，每个线程解析一个sheet里的数据，等到 所有的sheet都解析完之后，程序需要提示解析完成。在这个需求中，要 实现主线程等待所有线程完成sheet的解析操作，最简单的做法是使用 join()方法，如代码清单：

public class JoinCountDownLatchTest { 
	public static void main(String[] args) throws InterruptedException { 
	Thread parser1 = new Thread(new Runnable() {
	@Override 
	public void run() { 
		} 
	}); 
Thread parser2 = new Thread(new Runnable() { 
	@Override 
	public void run() { 
		System.out.println("parser2 finish"); 
	} 
}); 
		parser1.start(); 
		parser2.start(); 
		parser1.join(); 
		parser2.join(); 
		System.out.println("all parser finish"); 
	} 
}

join用于让当前执行线程等待join线程执行完毕。其实现原理就是不停的是检查join线程是否存活，如果join线程是存活状态，则执行线程等待。代码片段如下：

while (isAlive()) { 
	//其中wait（0）是让线程永远等待下去
	wait(0); 
}

直到join线程终止后，线程的this.notifyAll()方法会被调用，调用notifyAll()方法是在JVM中实现的。

采用CountDownLatch实现join功能：

public class CountDownLatchTest { 
	staticCountDownLatch c = new CountDownLatch(2); 	public static void main(String[] args) throws InterruptedException { 
	new Thread(new Runnable() { 
		@Override 
		public void run() { 
			System.out.println(1); 
			c.countDown(); 
			System.out.println(2); 
			c.countDown();
		} 
	}).start(); 
		c.await(); 
		System.out.println("3"); 
	} 
}

CountDownLatch的构造函数接收一个int类型的参数作为计数器，如果你想等待N点完成，那么就传入N；
当我们调用CountDownLatch的countDown方法时，N就会减1， CountDownLatch的await方法会阻塞当前线程，直到N变成零。由于 countDown方法可以用在任何地方，所以这里说的N个点，可以是N个线 程，也可以是1个线程里的N个执行步骤。用在多个线程时，只需要把 这个CountDownLatch的引用传递到线程里即可。 如果有某个解析sheet的线程处理得比较慢，我们不可能让主线程一 直等待，所以可以使用另外一个带指定时间的await方法——await（long time，TimeUnit unit），这个方法等待特定时间后，就会不再阻塞当前 线程。join也有类似的方法。

2、CyclicBarrier：
CyclicBarrier的字面意思是可循环利用（Cyclic）的屏障（Barrier）,
它要做的事情就是让一组线程到达一个屏障是被阻塞，只有最后一个线程到达屏障点，屏障的门才会打开，被拦截的线程才会继续执行。
CyclicBarrier默认的构造方法是CyclicBarrier（int parties），其参数 表示屏障拦截的线程数量，每个线程调用await方法告诉CyclicBarrier我 已经到达了屏障，然后当前线程被阻塞。示例代码如代码清单：

public class CyclicBarrierTest { 
staticCyclicBarrier c = new CyclicBarrier(2); 
	public static void main(String[] args) { 
		new Thread(new Runnable() { 
			@Override 
			public void run() { 
				try {
					c.await(); 
				} catch (Exception e) {
			 	}
			 	System.out.println(1); 
			} 
		 }).start(); 
		 try { 
		 	c.await(); 
		 } catch (Exception e) {
		  
		 }
	 	System.out.println(2); 
	 } 
}

因为主线程和子线程的调度是由CPU决定的，两个线程都有可能先 执行，所以会产生两种输出：1 2 或2 1

CyclicBarrier还提供一个更高级的构造函数CyclicBarrier（int
parties，Runnable barrier-Action），用于在线程到达屏障时，优先执行 barrierAction，方便处理更复杂的业务场景，如代码所示：

import java.util.concurrent.CyclicBarrier; 
public class CyclicBarrierTest2 { 
	static CyclicBarrier c = new CyclicBarrier(2, new A()); 
	public static void main(String[] args) { 
		new Thread(new Runnable() { 
			@Override 
			public void run() { 
				try { 
					c.await(); 
				} catch (Exception e) { 
				}
				System.out.println(1); 
			} 
		}).start(); 
		try { 
			c.await(); 
		} catch (Exception e) { 
		}
		System.out.println(2); 
	}
	static class A implements Runnable { 
		@Override 
		public void run() { 
			System.out.println(3); 
		} 
	} 
}

CyclicBarrier的应用场景：
CyclicBarrier可以用于多线程计算数据，最后合并计算结果的场 景。例如，用一个Excel保存了用户所有银行流水，每个Sheet保存一个 账户近一年的每笔银行流水，现在需要统计用户的日均银行流水，先用 多线程处理每个sheet里的银行流水，都执行完之后，得到每个sheet的日 均银行流水，最后，再用barrierAction用这些线程的计算结果，计算出 整个Excel的日均银行流水，如代码所示。

import java.util.Map.Entry; 
import java.util.concurrent.BrokenBarrierException; import java.util.concurrent.ConcurrentHashMap; 
import java.util.concurrent.CyclicBarrier; 
import java.util.concurrent.Executor; 
import java.util.concurrent.Executors; 
/*** 银行流水处理服务类 ** @authorftf **/ 
public class BankWaterService implements Runnable { 
	/*** 创建4个屏障，处理完之后执行当前类的run方法 */ 
	private CyclicBarrier c = new CyclicBarrier(4, this); 	
	/*** 假设只有4个sheet，所以只启动4个线程 */ 
	private Executor executor = Executors.newFixedThreadPool(4); 
/*** 保存每个sheet计算出的银流结果 */ 
	private ConcurrentHashMap<String, Integer>sheetBankWaterCount = new ConcurrentHashMap<String, Integer>(); 
	privatevoid count() { 
		for (inti = 0; i< 4; i++) { 
			executor.execute(new Runnable() { 
					@Override 
					public void run() { 
					// 计算当前sheet的银流数据，计算代码省略 
					sheetBankWaterCount.put(Thread.currentThread().getName(), 1); 
				// 银流计算完成，插入一个屏障 
					try { 
						c.await(); 
					} catch (InterruptedException | BrokenBarrierException e) { 
						e.printStackTrace(); 
					} 
			 } 
		}); 
	} 
} 
@Override 
public void run() {
	 intresult = 0; 
	 // 汇总每个sheet计算出的结果 
	 for (Entry<String, Integer>sheet :sheetBankWaterCount.entrySet()) { 
	 	result += sheet.getValue(); 
	 }
	// 将结果输出 
	sheetBankWaterCount.put("result", result); 	
		System.out.println(result); 
}
	public static void main(String[] args) { 
		BankWaterService bankWaterCount = new BankWaterService(); 
		bankWaterCount.count(); 
	} 
}

CyclicBarrier与CountDownLatch的区别：
CountDownLatch的计数器只能使用一次，而CyclicBarrier的计数器 可以使用reset()方法重置。所以CyclicBarrier能处理更为复杂的业务场 景。例如，如果计算发生错误，可以重置计数器，并让线程重新执行一 次。

CountDownLatch与join的区别：
join和countDownLatch都能实现让当前线程阻塞等待其他线程执行完毕，join使用起来更简便，不过countDownLatch粒度更细。
由于CountDownLatch需要开发人员很明确需要等待的条件，否则容易造成await()方法一直阻塞。