【小家java】JUC并发编程工具之CountDownLatch（闭锁）、CyclicBarrier、Semaphore的使用（上）

public void await() throws InterruptedException { };   //调用await()方法的线程会被挂起，它会等待直到count值为0才继续执行
public boolean await(long timeout, TimeUnit unit) throws InterruptedException { };  //和await()类似，只不过等待一定的时间后count值还没变为0的话就会继续执行
public void countDown() { };  //将count值减1

/**
 * 基类：定义了检查的行为
 *
 * @author fangshixiang
 * @description //
 * @date 2018/12/15 14:52
 */
@Getter
public abstract class BaseHealthChecker implements Runnable {
    private String serviceName; //检查的名称：如网络检查 DB检查 redis检查等等
    private boolean serviceUp; //是否健康 up
    //闭锁应该是同一把 所以传进来
    private CountDownLatch latch;
    public BaseHealthChecker(String serviceName, CountDownLatch latch) {
        super();
        this.latch = latch;
        this.serviceName = serviceName;
        this.serviceUp = false;
    }
    @Override
    public void run() {
        try {
            verifyService();
            serviceUp = true;
        } catch (Throwable t) {
            t.printStackTrace(System.err);
            serviceUp = false;
        } finally {
            if (latch != null) {
                latch.countDown();
            }
        }
    }
    /**
     * 各调用者只需要去实现这个行为即可（此处需要注意：不要返回值  我会认为没有报错 就认为是健康的）
     */
    public abstract void verifyService();
}

/**
 * 检查网络
 *
 * @author fangshixiang
 * @description //
 * @date 2018/12/15 14:53
 */
public class NetworkHealthChecker extends BaseHealthChecker {
    public NetworkHealthChecker(CountDownLatch latch) {
        super("Network Service", latch);
    }
    //模拟网络检查  只要不抛出异常 就认为是up的
    @Override
    public void verifyService() {
        System.out.println("Checking " + this.getServiceName());
        try {
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.getServiceName() + " is UP");
    }
}

/**
 * 检查DB数据库
 *
 * @author fangshixiang
 * @description //
 * @date 2018/12/15 14:53
 */
public class DBHealthChecker extends BaseHealthChecker {
    public DBHealthChecker(CountDownLatch latch) {
        super("Network Service", latch);
    }
    //模拟网络检查  只要不抛出异常 就认为是up的
    @Override
    public void verifyService() {
        System.out.println("Checking " + this.getServiceName());
        try {
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println(this.getServiceName() + " is UP");
    }
}

    //需要进行健康检查的所有的服务们
    private static List<BaseHealthChecker> services = new ArrayList<>();
    //闭锁
    private static CountDownLatch latch;
    private static boolean checkServiceIsUp() throws InterruptedException {
        //先必须要知道 一共有哪些服务是需要健康检查的
        latch = new CountDownLatch(3);
        services.add(new NetworkHealthChecker(latch));
        services.add(new DBHealthChecker(latch));
        services.add(new RedisHealthChecker(latch));
        //启动一个线程池  开多线程去同时健康检查
        Executor executor = Executors.newFixedThreadPool(services.size());
        for (final BaseHealthChecker v : services) {
            executor.execute(v);
        }
        latch.await();
        for (BaseHealthChecker v : services) {
            if (!v.isServiceUp()) {
                return false;
            }
        }
        return true;
    }
    public static void main(String[] args) throws InterruptedException {
        boolean b = checkServiceIsUp();
        System.out.println("总体服务的up状态为：" + b);
    }
输出：
Checking Network Service
Checking DB Service
Checking Redis Service
Network Service is UP
DB Service is UP
Redis Service is UP
总体服务的up状态为：true