同步机制之--java之CountDownLatch闭锁

CountDownLatch闭锁

1、类介绍

一个同步辅助类，在完成一组正在其他线程中执行的操作之前，它允许一个或多个线程一直等待。用给定的计数初始化 CountDownLatch。CountDownLatch类是一个同步计数器,构造时传入int参数,该参数就是计数器的初始值，每调用一次countDown()方法，计数器减1,计数器大于0 时，await()方法会阻塞程序继续执行。由于调用了 countDown() 方法，所以在当前计数到达零之前，await 方法会一直受阻塞。之后，会释放所有等待的线程，await 的所有后续调用都将立即返回。这种现象只出现一次——计数无法被重置。 一个线程(或者多个)， 等待另外N个线程完成某个事情之后才能执行。

2、使用场景

在一些应用场合中，需要等待某个条件达到要求后才能做后面的事情；同时当线程都完成后也会触发事件，以便进行后面的操作。 这个时候就可以使用CountDownLatch。CountDownLatch最重要的方法是countDown()和await()，前者主要是倒数一次，后者是等待倒数到0，如果没有到达0，就只有阻塞等待了。

 

3、方法说明

 

countDown

public void countDown()

递减锁存器的计数，如果计数到达零，则释放所有等待的线程。如果当前计数大于零，则将计数减少。如果新的计数为零，出于线程调度目的，将重新启用所有的等待线程。

如果当前计数等于零，则不发生任何操作。

await

public boolean await(long timeout,
                     TimeUnit unit)
              throws InterruptedException

使当前线程在锁存器倒计数至零之前一直等待，除非线程被中断或超出了指定的等待时间。如果当前计数为零，则此方法立刻返回 true 值。

如果当前计数大于零，则出于线程调度目的，将禁用当前线程，且在发生以下三种情况之一前，该线程将一直处于休眠状态：

• 由于调用 countDown() 方法，计数到达零；或者
• 其他某个线程中断当前线程；或者
• 已超出指定的等待时间。

如果计数到达零，则该方法返回 true 值。

如果当前线程：

• 在进入此方法时已经设置了该线程的中断状态；或者
• 在等待时被中断，

则抛出 InterruptedException，并且清除当前线程的已中断状态。如果超出了指定的等待时间，则返回值为 false。如果该时间小于等于零，则此方法根本不会等待。

参数：

timeout - 要等待的最长时间

unit - timeout 参数的时间单位。

返回：

如果计数到达零，则返回 true；如果在计数到达零之前超过了等待时间，则返回 false

抛出：

InterruptedException - 如果当前线程在等待时被中断

4、相关实例

import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class CountDownLatchTest {

    // 模拟了100米赛跑，10名选手已经准备就绪，只等裁判一声令下。当所有人都到达终点时，比赛结束。
    public static void main(String[] args) throws InterruptedException {

        // 开始的倒数锁
        final CountDownLatch begin = new CountDownLatch(1);

        // 结束的倒数锁
        final CountDownLatch end = new CountDownLatch(10);

        // 十名选手
        final ExecutorService exec = Executors.newFixedThreadPool(10);

        for (int index = 0; index < 10; index++) {
            final int NO = index + 1;
            Runnable run = new Runnable() {
                public void run() {
                    try {
                        // 如果当前计数为零，则此方法立即返回。
                        System.out.println("No." + NO +" ready");
                        // 等待
                        begin.await();
                        Thread.sleep((long) (Math.random() * 10000));
                        System.out.println("No." + NO + " arrived");
                    } catch (InterruptedException e) {
                    } finally {
                        // 每个选手到达终点时，end就减一
                        end.countDown();
                    }
                }
            };
            exec.submit(run);
        }
        System.out.println("Game Start");
        // begin减一，开始游戏
        begin.countDown();
        // 等待end变为0，即所有选手到达终点
        end.await();
        System.out.println("Game Over");
        exec.shutdown();
    }
}

5、输出结果

No.1 ready
Game Start
No.3 ready
No.5 ready
No.7 ready
No.9 ready
No.2 ready
No.4 ready
No.6 ready
No.8 ready
No.10 ready
No.5 arrived
No.6 arrived
No.7 arrived
No.9 arrived
No.2 arrived
No.4 arrived
No.3 arrived
No.1 arrived
No.8 arrived
No.10 arrived
Game Over

示例2, 转自http://blog.csdn.net/lmj623565791/article/details/26626391

一家人一起吃个饭

实现1：定义了一个volatile修饰的int类型变量，初始值为3，当为0时代表一家人齐了，于是我们在主线程使用了一个忙等，一直等待所有人到达，代码如下

package com.dxz.countdownlatch;

public class CountDownLatchTest {

    /**
     * 模拟爸爸去饭店
     */
    public static void fatherToRes() {
        System.out.println("爸爸步行去饭店需要3小时。");
    }

    /**
     * 模拟妈妈去饭店
     */
    public static void motherToRes() {
        System.out.println("妈妈挤公交去饭店需要2小时。");
    }

    /**
     * 模拟我去饭店
     */
    public static void meToRes() {
        System.out.println("我乘地铁去饭店需要1小时。");
    }

    /**
     * 模拟一家人到齐了
     */
    public static void togetherToEat() {
        System.out.println("一家人到齐了，开始吃饭");
    }

    private static volatile int i = 3;

    public static void main(String[] args) {

        new Thread() {
            public void run() {
                fatherToRes();
                i--;
            };
        }.start();
        new Thread() {
            public void run() {
                motherToRes();
                i--;
            };
        }.start();
        new Thread() {
            public void run() {
                meToRes();
                i--;
            };
        }.start();

        while (i != 0) {
            try {
                Thread.sleep(1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("循环阻塞主线程,模拟等待");
        }
        togetherToEat();
    }
}

结果：

循环阻塞主线程,模拟等待
爸爸步行去饭店需要3小时。
我乘地铁去饭店需要1小时。
循环阻塞主线程,模拟等待
循环阻塞主线程,模拟等待
循环阻塞主线程,模拟等待
循环阻塞主线程,模拟等待
循环阻塞主线程,模拟等待
妈妈挤公交去饭店需要2小时。
循环阻塞主线程,模拟等待
一家人到齐了，开始吃饭

上面的实现中，忙等这样的代码对于CPU的消耗太巨大了，我们需要更好的实现方式。顺便说一下volatile，为什么我们用volatile修饰 i 呢， 因为当多个线程操作同一个变量时，为了保证变量修改对于其他线程的可见性，必须使用同步，volatile对于可见性的实现是个不错的选择，但是我们代码中的 i -- 也有可能因为并发造成一定的问题，毕竟i--不是原子操作，正常最好使用同步块或者AtomicLong.decrementAndGet()实现--。

实现2：使用闭锁

package com.dxz.countdownlatch;

import java.util.concurrent.CountDownLatch;

public class CountDownLatchTest {

    /**
     * 模拟爸爸去饭店
     */
    public static void fatherToRes() {
        System.out.println("爸爸步行去饭店需要3小时。");
    }

    /**
     * 模拟妈妈去饭店
     */
    public static void motherToRes() {
        System.out.println("妈妈挤公交去饭店需要2小时。");
    }

    /**
     * 模拟我去饭店
     */
    public static void meToRes() {
        System.out.println("我乘地铁去饭店需要1小时。");
    }

    /**
     * 模拟一家人到齐了
     */
    public static void togetherToEat() {
        System.out.println("一家人到齐了，开始吃饭");
    }

    private static CountDownLatch latch = new CountDownLatch(3); 

    public static void main(String[] args) throws InterruptedException
    {  

        new Thread()
        {
            public void run()
            {
                fatherToRes();
                latch.countDown();
            };
        }.start();
        new Thread()
        {
            public void run()
            {
                motherToRes();
                latch.countDown();
            };
        }.start();
        new Thread()
        {
            public void run()
            {
                meToRes();
                latch.countDown();
            };
        }.start();  

        latch.await();
        togetherToEat();
    }
}

结果：

爸爸步行去饭店需要3小时。
妈妈挤公交去饭店需要2小时。
我乘地铁去饭店需要1小时。
一家人到齐了，开始吃饭

避免使用忙等，我们使用了CountDowmLatch 实现了我们的需求。下面具体介绍一下：

Latch闭锁的意思，是一种同步的工具类。类似于一扇门：在闭锁到达结束状态之前，这扇门一直是关闭着的，不允许任何线程通过，当到达结束状态时，这扇门会打开并允许所有的线程通过。且当门打开了，就永远保持打开状态。

作用：可以用来确保某些活动直到其他活动都完成后才继续执行。

使用场景：

1、例如我们上例中所有人都到达饭店然后吃饭；

2、某个操作需要的资源初始化完毕

3、某个服务依赖的线程全部开启等等...

CountDowmLatch是一种灵活的闭锁实现，包含一个计数器，该计算器初始化为一个正数，表示需要等待事件的数量。countDown方法递减计数器，表示有一个事件发生，而await方法等待计数器到达0，表示所有需要等待的事情都已经完成。