Java1.6提供了一个非常高效实用的多线程包:java.util.concurrent, 提供了大量高级工具,可以帮助开发者编写高效、易维护、结构清晰的Java多线程程序。从这篇blog起,我将跟大家一起共同学习这些新的Java多线程构件
1. CountDownLatch
我们先来学习一下JDK1.6 API中关于这个类的详细介绍:
“一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。 用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier。”
这就是说,CountDownLatch可以用来管理一组相关的线程执行,只需在主线程中调用CountDownLatch 的await方法(一直阻塞),让各个线程调用countDown方法。当所有的线程都只需完countDown了,await也顺利返回,不再阻塞了。在这样情况下尤其适用:将一个任务分成若干线程执行,等到所有线程执行完,再进行汇总处理。
下面我举一个非常简单的例子。 假设我们要打印1-100,最后再输出“Ok“。1-100的打印顺序不要求统一,只需保证“Ok“是在最后出现即可。
解决方案:我们定义一个CountDownLatch,然后开10个线程分别打印(n-1)*10+1至(n-1)*10+10。主线程中调用await方法等待所有线程的执行完毕,每个线程执行完毕后都调用countDown方法。最后再await返回后打印“Ok”。
具体代码如下(本代码参考了JDK示例代码):
总结:CounDownLatch对于管理一组相关线程非常有用。上述示例代码中就形象地描述了两种使用情况。第一种是计算器为1,代表了两种状态,开关。第二种是计数器为N,代表等待N个操作完成。今后我们在编写多线程程序时,可以使用这个构件来管理一组独立线程的执行。
2. CyclicBarrier
我们先来学习一下JDK1.5 API中关于这个类的详细介绍:
“一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环 的 barrier。
CyclicBarrier 支持一个可选的 Runnable 命令,在一组线程中的最后一个线程到达之后(但在释放所有线程之前),该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态,此屏障操作 很有用。
我们在学习CountDownLatch的时候就提到了CyclicBarrier。两者究竟有什么联系呢?引用[JCIP]中的描述“The key difference is that with a barrier, all the threads must come together at a barrier point at the same time in order to proceed. Latches are for waiting for events; barriers are for waiting for other threads。CyclicBarrier等待所有的线程一起完成后再执行某个动作。这个功能CountDownLatch也同样可以实现。但是CountDownLatch更多时候是在等待某个事件的发生。在CyclicBarrier中,所有的线程调用await方法,等待其他线程都执行完。
举一个很简单的例子, 今天晚上我们哥们4个去Happy。就互相通知了一下:晚上八点准时到xx酒吧门前集合,不见不散!。有个哥们住的近,早早就到了。有的事务繁忙,刚好踩点到了。无论怎样,先来的都不能独自行动,只能等待所有人
代码如下(参考了网上给的一些教程)
关于await方法要特别注意一下,它有可能在阻塞的过程中由于某些原因被中断
总结:CyclicBarrier就是一个栅栏,等待所有线程到达后再执行相关的操作。barrier 在释放等待线程后可以重用。
1. CountDownLatch
我们先来学习一下JDK1.6 API中关于这个类的详细介绍:
“一个同步辅助类,在完成一组正在其他线程中执行的操作之前,它允许一个或多个线程一直等待。 用给定的计数 初始化 CountDownLatch。由于调用了 countDown() 方法,所以在当前计数到达零之前,await 方法会一直受阻塞。之后,会释放所有等待的线程,await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。如果需要重置计数,请考虑使用 CyclicBarrier。”
这就是说,CountDownLatch可以用来管理一组相关的线程执行,只需在主线程中调用CountDownLatch 的await方法(一直阻塞),让各个线程调用countDown方法。当所有的线程都只需完countDown了,await也顺利返回,不再阻塞了。在这样情况下尤其适用:将一个任务分成若干线程执行,等到所有线程执行完,再进行汇总处理。
下面我举一个非常简单的例子。 假设我们要打印1-100,最后再输出“Ok“。1-100的打印顺序不要求统一,只需保证“Ok“是在最后出现即可。
解决方案:我们定义一个CountDownLatch,然后开10个线程分别打印(n-1)*10+1至(n-1)*10+10。主线程中调用await方法等待所有线程的执行完毕,每个线程执行完毕后都调用countDown方法。最后再await返回后打印“Ok”。
具体代码如下(本代码参考了JDK示例代码):
- import java.util.concurrent.CountDownLatch;
- /**
- * 示例:CountDownLatch的使用举例
- * Mail: ken@iamcoding.com
- * @author janeky
- */
- public class TestCountDownLatch {
- private static final int N = 10;
- public static void main(String[] args) throws InterruptedException {
- CountDownLatch doneSignal = new CountDownLatch(N);
- CountDownLatch startSignal = new CountDownLatch(1);//开始执行信号
- for (int i = 1; i <= N; i++) {
- new Thread(new Worker(i, doneSignal, startSignal)).start();//线程启动了
- }
- System.out.println("begin------------");
- startSignal.countDown();//开始执行啦
- doneSignal.await();//等待所有的线程执行完毕
- System.out.println("Ok");
- }
- static class Worker implements Runnable {
- private final CountDownLatch doneSignal;
- private final CountDownLatch startSignal;
- private int beginIndex;
- Worker(int beginIndex, CountDownLatch doneSignal,
- CountDownLatch startSignal) {
- this.startSignal = startSignal;
- this.beginIndex = beginIndex;
- this.doneSignal = doneSignal;
- }
- public void run() {
- try {
- startSignal.await(); //等待开始执行信号的发布
- beginIndex = (beginIndex - 1) * 10 + 1;
- for (int i = beginIndex; i < beginIndex + 10; i++) {
- System.out.println(i);
- }
- } catch (InterruptedException e) {
- e.printStackTrace();
- } finally {
- doneSignal.countDown();
- }
- }
- }
- }
总结:CounDownLatch对于管理一组相关线程非常有用。上述示例代码中就形象地描述了两种使用情况。第一种是计算器为1,代表了两种状态,开关。第二种是计数器为N,代表等待N个操作完成。今后我们在编写多线程程序时,可以使用这个构件来管理一组独立线程的执行。
2. CyclicBarrier
我们先来学习一下JDK1.5 API中关于这个类的详细介绍:
“一个同步辅助类,它允许一组线程互相等待,直到到达某个公共屏障点 (common barrier point)。在涉及一组固定大小的线程的程序中,这些线程必须不时地互相等待,此时 CyclicBarrier 很有用。因为该 barrier 在释放等待线程后可以重用,所以称它为循环 的 barrier。
CyclicBarrier 支持一个可选的 Runnable 命令,在一组线程中的最后一个线程到达之后(但在释放所有线程之前),该命令只在每个屏障点运行一次。若在继续所有参与线程之前更新共享状态,此屏障操作 很有用。
我们在学习CountDownLatch的时候就提到了CyclicBarrier。两者究竟有什么联系呢?引用[JCIP]中的描述“The key difference is that with a barrier, all the threads must come together at a barrier point at the same time in order to proceed. Latches are for waiting for events; barriers are for waiting for other threads。CyclicBarrier等待所有的线程一起完成后再执行某个动作。这个功能CountDownLatch也同样可以实现。但是CountDownLatch更多时候是在等待某个事件的发生。在CyclicBarrier中,所有的线程调用await方法,等待其他线程都执行完。
举一个很简单的例子, 今天晚上我们哥们4个去Happy。就互相通知了一下:晚上八点准时到xx酒吧门前集合,不见不散!。有个哥们住的近,早早就到了。有的事务繁忙,刚好踩点到了。无论怎样,先来的都不能独自行动,只能等待所有人
代码如下(参考了网上给的一些教程)
- import java.util.Random;
- import java.util.concurrent.BrokenBarrierException;
- import java.util.concurrent.CyclicBarrier;
- import java.util.concurrent.ExecutorService;
- import java.util.concurrent.Executors;
- public class TestCyclicBarrier {
- public static void main(String[] args) {
- ExecutorService exec = Executors.newCachedThreadPool();
- final Random random=new Random();
- final CyclicBarrier barrier=new CyclicBarrier(4,new Runnable(){
- @Override
- public void run() {
- System.out.println("大家都到齐了,开始happy去");
- }});
- for(int i=0;i<4;i++){
- exec.execute(new Runnable(){
- @Override
- public void run() {
- try {
- Thread.sleep(random.nextInt(1000));
- } catch (InterruptedException e) {
- e.printStackTrace();
- }
- System.out.println(Thread.currentThread().getName()+"到了,其他哥们呢");
- try {
- barrier.await();//等待其他哥们
- } catch (InterruptedException e) {
- e.printStackTrace();
- } catch (BrokenBarrierException e) {
- e.printStackTrace();
- }
- }});
- }
- exec.shutdown();
- }
- }
关于await方法要特别注意一下,它有可能在阻塞的过程中由于某些原因被中断
总结:CyclicBarrier就是一个栅栏,等待所有线程到达后再执行相关的操作。barrier 在释放等待线程后可以重用。