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