CountDownLatch学习

看了几篇博客，说用CountDownLatch实现一个先执行完子线程，再执行主线程的例子。因此写一篇博客总结一下。

一、CountDownLatch了解

1.CountDownLatch继承了AbstractQueuedSynchronizer类,很多方法都封装了在这个类里面，感兴趣可以看一下。内部写了一个Sync类，对其进行各种操作，以完成各个功能。

2.其原理是实现了一个计数器，通过对计数器操作，来实现对各个子线程的监控

二、例子

1.在启动服务前，需要对各个组件进行健康检查，因此设计一个方案，对各个组件进行检查，环境都ok后，再执行主线程。

2.先定义一个抽象类，该类实现了Runnable，用来进行健康检查

public abstract class BaseHealthChecker implements Runnable {
    //Counter
    private CountDownLatch counter;
    private String serviceName;
    private boolean isServiceOk;

    public abstract void checkHealth();

    public String getServiceName() {
        return serviceName;
    }

    public boolean isServiceOk() {
        return isServiceOk;
    }

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

    @Override
    public void run() {
        try {
            checkHealth();
            isServiceOk = true;
        } catch (Throwable t) {
            t.printStackTrace();
            isServiceOk = false;
        } finally {
            //Always count down counter
            if (counter != null) {
                counter.countDown();
            }
        }
    }
}

3.再定义一个HealthChecker. 

package countdownlatch;

import java.util.concurrent.CountDownLatch;

/**
 * Created by adrian.wu on 2018/12/18.
 */
public class HealthChecker extends BaseHealthChecker{
    public HealthChecker(String serviceName, CountDownLatch counter){
        super(serviceName, counter);
    }

    @Override
    public void checkHealth(){
        System.out.println("Check " + this.getServiceName());
        try {
            Thread.sleep(7000);
        }catch (InterruptedException e){
            e.printStackTrace();
        }
        System.out.println(this.getServiceName() + " is Ok");
    }
}

4.设定要检查哪些service

package countdownlatch;

import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.Executor;
import java.util.concurrent.Executors;

/**
 * Created by adrian.wu on 2018/12/18.
 */
public class ApplicationStartupUtil {
    private static List<BaseHealthChecker> services;

    private static CountDownLatch latch;

    private ApplicationStartupUtil() {
    }

    private final static ApplicationStartupUtil INSTANCE = new ApplicationStartupUtil();

    public static ApplicationStartupUtil getInstance() {
        return INSTANCE;
    }

    public static boolean checkExternalServices() throws Exception {
        //Initialize the service checkers
        latch = new CountDownLatch(4);

        services = new ArrayList<>();

        services.add(new HealthChecker("Flink Cluster", latch));

        services.add(new HealthChecker("Hbase Cluster", latch));

        services.add(new HealthChecker("Spark Cluster", latch));

        services.add(new HealthChecker("Kafka Cluster", latch));

        Executor executor = Executors.newFixedThreadPool(services.size());

        for (final BaseHealthChecker v : services) {
            executor.execute(v);
        }

        //wait all threads okay
        latch.await();

        for (final BaseHealthChecker v : services) {
            if (!v.isServiceOk()) {
                return false;
            }
        }

        return true;
    }
}

5.检查服务

package countdownlatch;

/**
 * Created by adrian.wu on 2018/12/18.
 */
public class Check {
    public static void main(String[] args) {
        boolean result = false;
        try {
            result = ApplicationStartupUtil.checkExternalServices();
        } catch (Exception e) {
            e.printStackTrace();
        }
        System.out.println("Services check is ok. Result: " + result);
    }
}

参考：http://www.importnew.com/15731.html