作者：王晨彥

我們在開發應用的時候，一般都會引入 SDK，而大部分 SDK 都要求我們在 Application 中初始化，當我們引入的 SDK 越來越多，就會出現 Application 越來越長，如果 SDK 的初始化任務相互依賴，還要處理很多條件判斷，這時，如果再來個異步初始化，相信大家都會崩潰。

有人可能會說，我都在主線程按順序初始化不就行了，當然行，只要老板不來找你麻煩。

「小王啊，咱們的 APP 啟動時間怎么這么久？」

開個玩笑，可見，一個優秀的啟動框架對于 APP 啟動性能而言，是多么的重要！

一、為什么不用 google 的 StartUp?

說到啟動框架，就不得不提 StartUp，畢竟是 Google 官方出品，現有的啟動框架，或多或少都有參考 StartUp，這里不再詳細介紹，如果對 StartUp 還不了解，可以參考這篇文章 Jetpack系列之App Startup從入門到出家。

https://juejin.cn/post/7023643365048582174

StartUp 提供了簡便的依賴任務初始化功能，但是對于一個復雜項目來說，StartUp 有以下不足：

1. 不支持異步任務

如果通過 ContentProvider 啟動，所有任務都在主線程執行，如果通過接口啟動，所有任務都在同一個線程執行。

2. 不支持組件化

通過 Class 指定依賴任務，需要引用依賴的模塊。

3. 不支持多進程

無法單獨配置任務需要執行的進程。

4. 不支持啟動優先級

雖然可以通過指定依賴來設置優先級，但是過于復雜。

二、一個合格的啟動框架是怎么樣的？

1. 支持異步任務

減少啟動時間的有效手段。

2. 支持組件化

其實就是解耦，一方面是解耦任務依賴，另一方面是解耦 app 和 module 的依賴。

3. 支持任務依賴

可以簡化我們的任務調度。

4. 支持優先級

在沒有依賴的情況下，允許任務優先執行。

5. 支持多進程

只在需要的進程中執行初始化任務，可以減輕系統負載，側面提升 APP 啟動速度。

三、收集任務

如果要做到完全解耦，我們可以使用 APT 收集任務。

首先定義注解，即任務的一些屬性。

@Target(AnnotationTarget.CLASS)
@Retention(AnnotationRetention.RUNTIME)
annotation class InitTask(
    /**
     * 任務名稱，需唯一
     */
    val name: String,
    /**
     * 是否在后臺線程執行
     */
    val background: Boolean = false,
    /**
     * 優先級，越小優先級越高
     */
    val priority: Int = PRIORITY_NORM,
    /**
     * 任務執行進程，支持主進程、非主進程、所有進程、:xxx、特定進程名
     */
    val process: Array<String> = [PROCESS_ALL],
    /**
     * 依賴的任務
     */
    val depends: Array<String> = []
)

name 作為任務唯一標識，類型為 String 主要是解耦任務依賴。

background 即是否后臺執行。

priority 是在主線程、無依賴場景下的執行順序。

process 指定了任務執行的進程，支持主進程、非主進程、所有進程、:xxx、特定進程名。

depends 指定依賴的任務。

任務的屬性定義好，還需要一個執行任務的接口：

interface IInitTask {
    fun execute(application: Application)
}

任務需要收集的信息已經定義好了，那么看一下一個真正的任務長什么樣。

@InitTask(
    name = "main",
    process = [InitTask.PROCESS_MAIN],
    depends = ["lib"]
)
class MainTask : IInitTask {
    override fun execute(application: Application) {
        SystemClock.sleep(1000)
        Log.e("WCY", "main1 execute")
    }
}

還是比較簡潔清晰的。

接下來需要通過 Annotation Processor 收集任務，然后通過 kotlin poet 寫入文件。

class TaskProcessor : AbstractProcessor() {

    override fun process(annotations: MutableSet<out TypeElement>?, roundEnv: RoundEnvironment): Boolean {
        val taskElements = roundEnv.getElementsAnnotatedWith(InitTask::class.JAVA)
        val taskType = elementUtil.getTypeElement("me.wcy.init.api.IInitTask")

        /**
         * Param type: MutableList<TaskInfo>
         *
         * There's no such type as MutableList at runtime so the library only sees the runtime type.
         * If you need MutableList then you'll need to use a ClassName to create it.
         * [https://github.com/square/kotlinpoet/issues/482]
         */
        val inputMapTypeName =
            ClassName("kotlin.collections", "MutableList").parameterizedBy(TaskInfo::class.asTypeName())

        /**
         * Param name: taskList: MutableList<TaskInfo>
         */
        val groupParamSpec = ParameterSpec.builder(ProcessorUtils.PARAM_NAME, inputMapTypeName).build()

        /**
         * Method: override fun register(taskList: MutableList<TaskInfo>)
         */
        val loadTaskMethodBuilder = FunSpec.builder(ProcessorUtils.METHOD_NAME)
            .addModifiers(KModifier.OVERRIDE)
            .addParameter(groupParamSpec)

        for (element in taskElements) {
            val typeMirror = element.asType()
            val task = element.getAnnotation(InitTask::class.java)
            if (typeUtil.isSubtype(typeMirror, taskType.asType())) {
                val taskCn = (element as TypeElement).asClassName()

                /**
                 * Statement: taskList.add(TaskInfo(name, background, priority, process, depends, task));
                 */
                loadTaskMethodBuilder.addStatement(
                    "%N.add(%T(%S, %L, %L, %L, %L, %T()))",
                    ProcessorUtils.PARAM_NAME,
                    TaskInfo::class.java,
                    task.name,
                    task.background,
                    task.priority,
                    ProcessorUtils.formatArray(task.process),
                    ProcessorUtils.formatArray(task.depends),
                    taskCn
                )
            }
        }

        /**
         * Write to file
         */
        FileSpec.builder(ProcessorUtils.PACKAGE_NAME, "TaskRegister$$moduleName")
            .addType(
                TypeSpec.classBuilder("TaskRegister$$moduleName")
                    .addKdoc(ProcessorUtils.JAVADOC)
                    .addSuperinterface(ModuleTaskRegister::class.java)
                    .addFunction(loadTaskMethodBuilder.build())
                    .build()
            )
            .build()
            .writeTo(filer)

        return true
    }
}

看一下生成的文件長什么樣。

public class TaskRegister$sample : ModuleTaskRegister {
  public override fun register(taskList: MutableList<TaskInfo>): Unit {
    taskList.add(TaskInfo("main2", true, 0, arrayOf("PROCESS_ALL"), arrayOf("main1","lib1"),MainTask2()))
    taskList.add(TaskInfo("main3", false, -1000, arrayOf("PROCESS_ALL"), arrayOf(), MainTask3()))
    taskList.add(TaskInfo("main1", false, 0, arrayOf("PROCESS_MAIN"), arrayOf("lib1"), MainTask()))
  }
}

sample 模塊收集到了3個任務，TaskInfo 對任務信息做了聚合。

我們知道 APT 可以生成代碼，但是無法修改字節碼，也就是說我們在運行時想到拿到注入的任務，還需要將收集的任務注入到源碼中。

這里可以借助 AutoRegister 幫我們完成注入。

https://github.com/luckybilly/AutoRegister

注入前：

internal class FinalTaskRegister {
    val taskList: MutableList<TaskInfo> = mutableListOf()

    init {
        init()
    }

    private fun init() {}

    fun register(register: ModuleTaskRegister) {
        register.register(taskList)
    }
}

將收集到的任務注入到 init 方法中，注入后的字節碼：

/* compiled from: FinalTaskRegister.kt */
public final class FinalTaskRegister {
    private final List<TaskInfo> taskList = new ArrayList();

    public FinalTaskRegister() {
        init();
    }

    public final List<TaskInfo> getTaskList() {
        return this.taskList;
    }

    private final void init() {
        register(new TaskRegister$sample_lib());
        register(new TaskRegister$sample());
    }

    public final void register(ModuleTaskRegister register) {
        Intrinsics.checkNotNullParameter(register, "register");
        register.register(this.taskList);
    }
}

我們通過 APT 生成的類已經成功的注入到代碼中。

小結

至此，我們已經完成了任務的收集，通過 APT 和字節碼修改是常見的類收集方案，相比反射，字節碼修改沒有任何性能的損失。

后來發現 Google 已經推出了新的注解處理框架 ksp，處理速度更快，于是果斷嘗試了一把，所以有兩種注解處理可以選擇，GitHub 上有詳細介紹。

四、任務調度

任務調度是啟動框架的核心，大家可能聽到過。

處理依賴任務首先要構建一個「有向無環圖」。

什么是有向無環圖，看下維基百科的介紹：

在圖論中，如果一個有向圖從任意頂點出發無法經過若干條邊回到該點，則這個圖是一個有向無環圖（DAG, Directed Acyclic Graph）。

聽起來好像很簡單，那么具體怎么實現呢，今天我們拋開高級概念不談，用代碼帶大家實現任務的調度。

首先，需要把任務分為兩類，有依賴的任務和無依賴的任務。

有依賴的首先檢查是否有環，如果有循環依賴，直接 throw，這個可以套用公式 —— 如何判斷鏈表是否有環。

如果沒有循環依賴，則收集每個任務的被依賴任務，我們稱之為子任務，用于當前任務執行完成后，繼續執行子任務。

無依賴的最簡單，直接按照優先級執行即可。

不知道大家是否有疑問：有依賴的任務什么時候啟動？

有依賴的任務，依賴鏈的葉子端點一定是一個無依賴的任務，因此無依賴的任務執行完成后，就可以開始執行有依賴的任務。

下面用一個小例子來介紹：

• A 依賴 B、C
• B 依賴 C
• C 無依賴

樹形結構：

1、分組并梳理子任務。

• 有依賴：

A: 無子任務

B: 子任務: [A]

• 無依賴：

C: 子任務: [A, B]

2、執行無依賴的任務C。

3、更新已完成的任務: [C]。

4、檢查 C 的子任務是否可以執行。

A: 依賴 [B, C]，已完成任務中不包含 B，無法啟動

B: 依賴 [C]，已完成任務中包含 C，可以執行

5、執行任務 B。

6、重復步驟 3，直到所有任務執行完成。

下面我們就用代碼來實現：

使用遞歸檢查循環依賴：

private fun checkCircularDependency(
    chain: List<String>,
    depends: Set<String>,
    taskMap: Map<String, TaskInfo>
) {
    depends.forEach { depend ->
        check(chain.contains(depend).not()) {
            "Found circular dependency chain: $chain -> $depend"
        }
        taskMap[depend]?.let { task ->
            checkCircularDependency(chain + depend, task.depends, taskMap)
        }
    }
}

梳理子任務：

task.depends.forEach {
    val depend = taskMap[it]
    checkNotNull(depend) {
        "Can not find task [$it] which depend by task [${task.name}]"
    }
    depend.children.add(task)
}

執行任務：

private fun execute(task: TaskInfo) {
    if (isMatchProgress(task)) {
        val cost = measureTimeMillis {
            kotlin.runCatching {
                (task.task as IInitTask).execute(app)
            }.onFailure {
                Log.e(TAG, "executing task [${task.name}] error", it)
            }
        }
        Log.d(
            TAG, "Execute task [${task.name}] complete in process [$processName] " +
                    "thread [${Thread.currentThread().name}], cost: ${cost}ms"
        )
    } else {
        Log.w( TAG, "Skip task [${task.name}] cause the process [$processName] not match")
    }
    afterExecute(task.name, task.children)
}

如果進程不匹配直接跳過。

繼續執行下一個任務：

private fun afterExecute(name: String, children: Set<TaskInfo>) {
    val allowTasks = synchronized(completedTasks) {
        completedTasks.add(name)
        children.filter { completedTasks.containsAll(it.depends) }
    }
    if (ThreadUtils.isInMainThread()) {
        // 如果是主線程，先將異步任務放入隊列，再執行同步任務
        allowTasks.filter { it.background }.forEach {
            launch(Dispatchers.Default) { execute(it) }
        }
        allowTasks.filter { it.background.not() }.forEach { execute(it) }
    } else {
        allowTasks.forEach {
            val dispatcher = if (it.background) Dispatchers.Default else Dispatchers.Main
            launch(dispatcher) { execute(it) }
        }
    }
}

如果子任務的依賴任務都已經執行完畢，就可以執行了。

最后還需要提供一個啟動任務的接口，為了支持多進程，這里不能使用 ContentProvider。

小結

通過層層拆解，將復雜的依賴梳理清楚，用通俗易懂的方法，實現任務調度。

源碼

https://github.com/wangchenyan/init

另外，我也在 JitPack 上發布了 alpha 版本，歡迎大家嘗試:

kapt "com.github.wangchenyan.init:init-compiler:1-alpha.1"
implementation "com.github.wangchenyan.init:init-api:1-alpha.1"

詳細使用請移步 GitHub。

https://github.com/wangchenyan/init

最后

本文以 StartUp 作為引子，闡述依賴任務啟動框架還需要具備哪些能力，通過 APT + 字節碼注入進行解耦，支持模塊化，通過一個簡單的模型來表述任務調度具體的實現方式。

希望本文能夠讓大家了解依賴任務啟動框架的核心思想，如果你有好的建議，歡迎評論交流探討。

在這里就還分享一份由大佬親自收錄整理的學習PDF+架構視頻+面試文檔+源碼筆記，高級架構技術進階腦圖、Android開發面試專題資料，高級進階架構資料

這些都是我現在閑暇時還會反復翻閱的精品資料。里面對近幾年的大廠面試高頻知識點都有詳細的講解。相信可以有效地幫助大家掌握知識、理解原理，幫助大家在未來取得一份不錯的答卷。

當然，你也可以拿去查漏補缺，提升自身的競爭力。

真心希望可以幫助到大家，Android路漫漫，共勉！