CountDownLatch

CountDownLatch 示例解析

最新推荐文章于 2025-02-19 01:44:20 发布

转载最新推荐文章于 2025-02-19 01:44:20 发布 · 2.1k 阅读

文章标签：

#import #module #random #string #任务 #class

Java 专栏收录该内容

28 篇文章

订阅专栏

本文通过一个项目开发模拟案例，详细介绍了 Java 并发工具 CountDownLatch 的使用方法及注意事项。CountDownLatch 有助于协调多个线程的任务执行流程，确保主线程等待所有子线程完成后再继续执行。

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。

用给定的计数初始化 CountDownLatch。由于调用了 countDown()
方法，所以在当前计数到达零之前，await
方法会一直受阻塞。之后，会释放所有等待的线程，await
的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。

package countdownlatch;
/**   
 * @author YYZ  
 * @version 2011-10-26 上午11:58:59
 */
import java.util.Random;  
import java.util.concurrent.CountDownLatch;  
import java.util.concurrent.ExecutorService;  
import java.util.concurrent.Executors;  
import java.util.concurrent.TimeUnit;  
  
/** 
 * 模拟项目的开发，只有当每个模块都完成后，项目才完成 
 * 每个模块的用时不同 
 * @author 小e 
 * 
 * 2010-4-30 下午07:41:37 
 */  
class Module implements Runnable{  
    private CountDownLatch latch;  
    private String moduleName;  
    private int time;//用时  
      
      
  
    public Module(CountDownLatch latch, String moduleName,int time) {  
        super();  
        this.latch = latch;  
        this.moduleName = moduleName;  
        this.time = time;  
    }  
  
  
  
    @Override  
    public void run() {  
        try {  
            work();  
            latch.countDown();  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
    }  
      
    private void work() throws InterruptedException{  
        TimeUnit.MILLISECONDS.sleep(time);  
        System.out.println(moduleName + " 完成，耗时:" + time);  
    }  
}  
class Controller implements Runnable{  
    private CountDownLatch latch;  
  
    public Controller(CountDownLatch latch) {  
        super();  
        this.latch = latch;  
    }  
  
    @Override  
    public void run() {  
        try {  
            latch.await();  
            System.out.println("所有模块都完成，任务完成");  
        } catch (InterruptedException e) {  
            // TODO Auto-generated catch block  
            e.printStackTrace();  
        }  
          
    }  
      
}  
public class Project {  
    static final int SIZE = 20;  
    public static void main(String[] args) {  
        CountDownLatch latch = new CountDownLatch(SIZE);  
        Random r = new Random();  
        ExecutorService exec = Executors.newCachedThreadPool();  
        Controller controller = new Controller(latch);  
        exec.execute(controller);  
        for(int i = 0; i < SIZE; i++){  
            exec.execute(new Module(latch, "模块" + (i + 1), r.nextInt(2000)));  
        }  
          
        exec.shutdown();  
          
    }  
  
}

模块5 完成，耗时:91
模块7 完成，耗时:306
模块3 完成，耗时:374
模块12 完成，耗时:384
模块8 完成，耗时:390
模块6 完成，耗时:415
模块14 完成，耗时:459
模块1 完成，耗时:557
模块4 完成，耗时:572
模块20 完成，耗时:572
模块18 完成，耗时:618
模块17 完成，耗时:711
模块2 完成，耗时:804
模块15 完成，耗时:995
模块11 完成，耗时:1261
模块10 完成，耗时:1360
模块13 完成，耗时:1412
模块19 完成，耗时:1913
模块16 完成，耗时:1937
模块9 完成，耗时:1976

所有模块都完成，任务完成

CountDownLatch 的局限性和 CompletionService 类似，在于无法处理子任务数量不确定的情况，例如统计某个文件夹中的文件数量。另外，如果某个子任务在调用 countDown 之前就挂掉了，倒计数就永远不会归零。对于这种情况，要么用 finally 之类的手段保证countDown 一定会被调用，要么用带参数的 await 方法指定超时时间