java多线程编程指南核心篇--CountDownLatch

CountDownLatch

使用CountDownLatch实现多线程加载服务，代码来自java多线程编程指南核心篇（说明下）

程序

Main入口

```java
public static void main(String [] args){
        //启动所有服务
        ServiceManager.startServices();

        //校验状态
        boolean flag = ServiceManager.checkServiceStatus();

        if(flag){
            System.out.println("**********服务启动完成**************");
        }else{
            System.err.println("**********服务异常，退出**************");
            System.exit(1);
        }
    }

## 服务抽象接口

```java

/**
 * 服务接口
 */
public interface Service{
    /**
     * 是否启动
     * @return
     */
    public boolean isStarted();

    /**
     * 执行方法
     * @throws Exception
     */
    public void doStart() throws Exception;

    /**
     * 启动
     */
    public void start();

    /**
     * 停止
     */
    public void stop();

}

实现服务部分方法，抽象类实现，后续服务需实现抽象类

import java.util.concurrent.CountDownLatch;

/**
 * 服务抽象类
 * 使用CountDownLatch
 */
public abstract class AbstractService implements Service {
    /**
     * 启动标识
     */
    protected boolean started = false;

    protected final CountDownLatch latch;

    public AbstractService(CountDownLatch latch){
        this.latch = latch;
    }

    /**
     * 是否启动成功
     * @return
     */
    @Override
    public boolean isStarted() {
        return started;
    }

    @Override
    public abstract void doStart() throws Exception;


    @Override
    public void start() {
        new ServiceStarter(this).start();
    }

    /**
     * 服务停止，未实现
     */
    @Override
    public void stop() {

    }
}

主要服务

public class LoadMenuService extends AbstractService {
    public LoadMenuService(CountDownLatch latch) {
        super(latch);
    }

    @Override
    public void doStart() throws Exception {
        System.out.println("***************************LoadMenuService***********");
    }
}

启动线程并且执行主要方法和修改完成状态

public class ServiceStarter extends Thread {

    private AbstractService doService;


    public ServiceStarter(AbstractService doService) {
        this.doService = doService;
    }

    @Override
    public void run() {
       final String simpleName =doService.getClass().getSimpleName();
        System.out.println("***********doService" + simpleName);
        try{
            doService.doStart();
            doService.started = true;
        }catch (Exception  e){
            e.printStackTrace();
        }finally {
            doService.latch.countDown();
        }
    }
}

服务管理，用于加载服务查看所有服务是否全部完成

import com.mvc.chapter5.service.LoadMenuService;
import com.mvc.chapter5.service.LoadShopService;
import com.mvc.chapter5.service.LoadUserInfoService;

import java.util.HashSet;
import java.util.Set;
import java.util.concurrent.CountDownLatch;

/**
 * 服务管理
 */
public class ServiceManager {
    protected static volatile CountDownLatch latch;
    /**
     * 服务集合
     */
    static Set<Service> serviceSet;

    public static void startServices(){
        serviceSet = getServiceSet();
        for(Service service : serviceSet){
            service.start();
        }
    }

    /**
     *
     * 判断所有服务是否执行成功，未执行完成主要线程等待
     * 如果有一个服务执行失败则返回false
     * @return
     */
    public static boolean checkServiceStatus(){
        try{
            latch.await();
        }catch (Exception e){
            e.printStackTrace();
            return false;
        }
        for (Service service : serviceSet) {
            if(!service.isStarted()){
                return false;
            }
        }
        return true;
    }

    /**
     *
     * 获取需要加载的服务方法
     * @return
     */
    static Set<Service> getServiceSet(){
        latch = new CountDownLatch(3);
        HashSet<Service> set = new HashSet<>();
        set.add(new LoadMenuService(latch));
        set.add(new LoadShopService(latch));
        set.add(new LoadUserInfoService(latch));
        return set;
    }
}