核心思想：子线程分担主线程任务，并行减少时间

常规异步

示例：

public class App extends Application {
    private CountDownLatch mCountDownLatch = new CountDownLatch(1);

    private static final int CPU_COUNT = Runtime.getRuntime().availableProcessors();
    private static final int CORE_POOL_SIZE = Math.max(2, Math.min(CPU_COUNT - 1, 4));

    @Override
    public void onCreate() {
        super.onCreate();
        ExecutorService executorService = Executors.newFixedThreadPool(CORE_POOL_SIZE);
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                initA();
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                initB();
            }
        });
        executorService.submit(new Runnable() {
            @Override
            public void run() {
                initC();
                mCountDownLatch.countDown();
            }
        });
        try {
            mCountDownLatch.await();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        //C初始完成后才可以进行下面的操作
    }

    private void initA() {
        //...
    }

    private void initB() {
        //...
    }

    private void initC() {
        //...
    }
}

痛点：

代码不优雅

场景不好处理（依赖关系）

维护成本高

启动器

核心思想：充分利用CPU多核，自动梳理任务顺序。

流程：

代码Task化，启动逻辑抽象为Task

根据所有任务依赖关系排序生成一个有向无环图

多线程按照排序后的优先级依次执行