Java中的CountDownLatch

CountDownLatch允许一个或多个线程等待其他线程完成操作。

假如,我们现在有这样一个需求,我们需要解析一个sheet中的数据,此时我们可以考虑多线程,一个线程解析一个sheet,当所有线程解析完sheet后,再进行统计。学过多线程的我们可以想到使用join方法解决。

public static void main(String[] args) throws InterruptedException {
    Thread t1 = new Thread(){
        @Override
        public void run() {
            System.out.println("线程A解析完成");
        }
    };
    Thread t2 = new Thread(){
        @Override
        public void run() {
            System.out.println("线程B解析完成");
        }
    };
    t1.start();
    t2.start();
    t1.join();
    t2.join();
    System.out.println("所有线程都已经解析完成");
}

上述代码就是启动两个线程去解析sheet,当线程1和线程2都执行完后,输出所有线程都解析完成


可以看到,线程A和线程B都执行完后,才输出所有线程解析完成。

问题来了,join方法用于让当前线程等待join线程执行结束。其实现原理是不停检查join线程是否存活。如果join线程存活则让当前线程永远等待。直到join线程中止后,线程的this.notifyAll方法会被调用,唤醒其他线程。

在JDK1.5的并发包里提供的CountDownLatch也能实现join的功能,并且比join的功能更多。

下来看看CountDownLatch是如何实现的

public static void main(String[] args) throws InterruptedException {
    CountDownLatch latch = new CountDownLatch(2);
    Thread t1 = new Thread(){
        @Override
        public void run() {
            System.out.println("线程A解析完成");
            latch.countDown();
        }
    };
    Thread t2 = new Thread(){
        @Override
        public void run() {
            System.out.println("线程B解析完成");
            latch.countDown();
        }
    };
    t1.start();
    t2.start();
    latch.await();
    System.out.println("所有线程都已经解析完成");
}

CountDownLatch的构造函数接收一个int类型的参数作为计数器,如果你想等待N个点完成,这里就传入N。

await方法相当于一道屏障,所有线程都会被阻挡在屏障外面,直到你传入的N变为0,。而调用一次countDown方法,N就会减1。当N变为0时,屏障就会消失。

如果某个线程处理的比较慢,我们不可能让主线程一直等待着,所以可以使用另外一个带指定时间的await方法,如果在特等的的时间内没有等到线程,就会不再阻塞当前线程。

getCount方法

    CountDownLatch有一个getCount方法,可以获得还需要几个才能通过屏障的数量。

假如现在你们要开会,假设有三个人,只有当三个人都到达时才能开始

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        System.out.println("准备开会,等待人员到齐");
        Thread t1 = new Thread(){
            @Override
            public void run() {
                System.out.println("你已经到了办公室");
                latch.countDown();
                System.out.println("还有"+latch.getCount()+"人没到");
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                System.out.println("他已经到了办公室");
                latch.countDown();
                System.out.println("还有"+latch.getCount()+"人没到");
            }
        };
        Thread t3 = new Thread(){
            @Override
            public void run() {
                System.out.println("我已经到了办公室");
                latch.countDown();
                System.out.println("还有"+latch.getCount()+"人没到");
            }
        };
        t1.start();
        t2.start();
        t3.start();
        latch.await();
        System.out.println("所有人都到齐了,开始开会");
    }
}

只有当三个人都到达时,才能开始开会。假设有一个来的比较迟呢,那我应该先开始开会,最后一个人来了之后参与其中。

public class Test2 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(3);
        System.out.println("准备开会,等待人员到齐");
        Thread t1 = new Thread(){
            @Override
            public void run() {
                System.out.println("你已经到了办公室");
                latch.countDown();
                System.out.println("还有"+latch.getCount()+"人没到");
            }
        };
        Thread t2 = new Thread(){
            @Override
            public void run() {
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("他已经到了办公室");
                latch.countDown();
                System.out.println("我来迟了,我们继续吧");
            }
        };
        Thread t3 = new Thread(){
            @Override
            public void run() {
                System.out.println("我已经到了办公室");
                latch.countDown();
                System.out.println("还有"+latch.getCount()+"人没到");
            }
        };
        t1.start();
        t2.start();
        t3.start();
        latch.await(3,TimeUnit.SECONDS);
        if (latch.getCount()>0){
            System.out.println("我们先开始开会");
        }else {
            System.out.println("所有人都到齐了,开始开会");
        }
    }
}

使用getCount和带参数的await即可以实现这种情况。

总结:

   在CountDownLatch对象时需要传入一个int类型的N值,将CountDownLatch.await当做门的话,这个值就代表了需要多少力量才能打开门。可以使用getCount来获得你还需要多少力量才能打开门。每次调用countDown就会将你传入的N减一,如果await方法判断N为0,则门消失。当N不为0时,所有线程都会被挡在门外,为了避免主线程一直等待,可以使用带参数的await方法,当等待指定时间后门还未打开,则门也消失。


  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
CountDownLatch 是一个同步工具类,在多线程环境常常用于控制线程的执行顺序或者等待某个事件的发生。它的主要作用是让一组线程等待某个事件的发生,当事件发生后,所有等待的线程都可以继续执行。 CountDownLatch 的使用步骤如下: 1. 创建一个 CountDownLatch 对象,指定需要等待的线程数。 2. 在需要等待的线程,调用 CountDownLatch 的 await() 方法,等待事件的发生。 3. 当事件发生时,调用 CountDownLatchcountDown() 方法,通知等待的线程可以继续执行。 下面是一个简单的例子: ``` import java.util.concurrent.CountDownLatch; public class CountDownLatchDemo { public static void main(String[] args) throws InterruptedException { CountDownLatch latch = new CountDownLatch(3); Thread t1 = new Thread(new Task("Task1", latch)); Thread t2 = new Thread(new Task("Task2", latch)); Thread t3 = new Thread(new Task("Task3", latch)); t1.start(); t2.start(); t3.start(); latch.await(); // 等待所有任务执行完成 System.out.println("All tasks have been completed."); } static class Task implements Runnable { private String name; private CountDownLatch latch; public Task(String name, CountDownLatch latch) { this.name = name; this.latch = latch; } @Override public void run() { System.out.println(name + " is running..."); try { Thread.sleep(1000); } catch (InterruptedException e) { e.printStackTrace(); } System.out.println(name + " has completed."); latch.countDown(); } } } ``` 在这个例子,我们创建了一个 CountDownLatch 对象,并指定需要等待的线程数为 3。然后创建了 3 个线程,并让它们执行一个简单的任务:输出线程名字、等待 1 秒钟,然后输出线程名字并调用 countDown() 方法。最后在主线程调用 await() 方法等待所有任务执行完成。当所有任务执行完成后,输出一条“所有任务已完成”的消息。

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值