java.util.concurrent|CountDownLatch使用

CountDownLatch能实现让一个线程等待其他线程执行完成后再继续执行的功能。
如下使用CountDownLatch实现服务检测功能，ApplicationStartupUtil调用服务的检测方法，使用CountDownLatch等待检测完成，再返回检测结果。

BaseHealthChecker.java

/**
 * 外部服务心跳检测抽象类
 *
 * @Auothor wzx
 * @Date 2017/3/11 0011
 */
public abstract class BaseHealthChecker implements Runnable {

    private String serviceName;

    private boolean serviceUp;

    private CountDownLatch countDownLatch;

    public BaseHealthChecker(String serviceName, CountDownLatch countDownLatch) {
        super();
        this.serviceName = serviceName;
        this.countDownLatch = countDownLatch;
        this.serviceUp = false;
    }

    @Override
    public void run() {
        try {
            verifyService();
            serviceUp = true;
        } catch (Throwable e) {
            e.printStackTrace();
            serviceUp = false;
        } finally {
            if (countDownLatch != null) {
                //表示完成任务
                countDownLatch.countDown();
            }
        }
    }

    public String getServiceName() {
        return serviceName;
    }

    public boolean isServiceUp() {
        return serviceUp;
    }

    //子类实现具体检测方法
    public abstract void verifyService();
}

NetworkHealthChecker.java

/**
        * 网络健康检测
        * @Auothor wzx
        * @Date 2017/3/11 0011
        */
public class NetworkHealthChecker extends BaseHealthChecker {


    public NetworkHealthChecker(CountDownLatch countDownLatch) {
        super("Network Service", countDownLatch);
    }

    @Override
    public void verifyService() {
        System.out.println("checking " + this.getServiceName());
        try {
            TimeUnit.SECONDS.sleep(3);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.getServiceName() + " is up");
    }
}

NetworkHealthChecker.java

/**
 * 应用启动工具类
 *
 * @Auothor wzx
 * @Date 2017/3/11 0011
 */
public class ApplicationStartupUtil {

    //保存要检测的服务
    private static List<BaseHealthChecker> serviceList;

    private static CountDownLatch latch;

    private static final ApplicationStartupUtil instance = new ApplicationStartupUtil();

    public static ApplicationStartupUtil getInstance() {
        return instance;
    }

    private ApplicationStartupUtil() {

    }

    public static boolean checkExternalServices() throws InterruptedException {
        latch = new CountDownLatch(2);

        serviceList = new ArrayList<>();
        serviceList.add(new NetworkHealthChecker(latch));
        serviceList.add(new DatabaseHealthChecker(latch));

        Executor executor = Executors.newFixedThreadPool(serviceList.size());
        for (BaseHealthChecker healthChecker : serviceList) {
            executor.execute(healthChecker);
        }

        latch.await();

        for (BaseHealthChecker healthChecker : serviceList) {
            if(!healthChecker.isServiceUp()) {
                return false;
            }
        }
        return true;
    }

}

Main.java

/**
 * @Auothor wzx
 * @Date 2017/3/11 0011
 */
public class Main {

    public static void main(String[] args) {
        boolean result = false;
        try {
            result = ApplicationStartupUtil.checkExternalServices();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("External services validation completed !! Result was :: "+ result);
    }

}

参考
http://howtodoinjava.com/core-java/multi-threading/when-to-use-countdownlatch-java-concurrency-example-tutorial/