前言

虽然本文的主题是启动器，但是笔者不打算去写怎么做启动优化，以及怎么实现一个完美的启动器。关于开源的第三方Android启动器已经有很多优秀的轮子了，比如阿里巴巴的alpha，参考 alpha 并改进其部分细节的Anchors，Start数比较高的android-startup，以及Android官方自己的app-startup等等。

本文的了灵感来源于我爱田Hebe的应用程序启动优化新思路 - Kotlin协程，并参考了以上开源库做了一些改造，以便用起来更丝滑。本文主要分享笔者基于这个思路进行改造的几个点，强烈建议先阅读灵感来源的这篇文章，再继续往下阅读。

整体代码

先看下改造后的代码有一个初步的了解：

XTask

任务类，主要是改了线程调度，增加优先级，增加Kotlin DSL相关方法，以及继承Observable。

/*
 * 任务
 */
data class XTask(
    val name: String,//任务名称，不可以重复
    val desc: String = "",//任务描述
    val coroutineDispatcher: CoroutineDispatcher = Dispatchers.Default,//线程调度
    val priority: Int = 0,   // 运行的优先级，值小的先执行,
    var dependentTasks: Set<String> = setOf(), // 依赖的任务集合(不可重复，所以用Set)
    val run: suspend () -> Boolean = { false }, //具体的执行任务的函数，为什么放在构造函数，主要是方便全局查看任务。返回是否拦截
) : Observable() {
    // 入度，用于有向无环图的拓扑排序
    var inDegree = dependentTasks.size

    /**
     * 通知通知观察者
     */
    fun notify(arg: Any) {
        setChanged()
        notifyObservers(arg)
    }

    /**
     * 构造任务集
     * @param tasks Array<out XTask>
     * @return MutableSet<String>
     */
    fun on(vararg tasks: XTask): MutableSet<XTask> {
        val dependentTasks = mutableSetOf<XTask>()
        if (tasks.isNotEmpty()) {
            for (task in tasks) {
                dependentTasks.add(task)
            }
        }
        return dependentTasks
    }

    /**
     * 设置当前任务依赖的任务集
     * @param tasks Set<XTask>
     * @return XTask
     */
    infix fun depends(tasks: Set<XTask>): XTask {
        if (tasks.isNotEmpty()) {
            val dependentTasks = mutableSetOf<String>()
            for (task in tasks) {
                dependentTasks.add(task.name)
            }
            this.dependentTasks = dependentTasks
            this.inDegree = this.dependentTasks.size
        }
        return this
    }

    /**
     * 设置当前任务依赖的任务集
     * @param block [@kotlin.ExtensionFunctionType] Function1<XTask, MutableSet<String>>
     * @return String 返回任务名称
     */
    fun depends(block: XTask.() -> MutableSet<XTask>): XTask {
        val tasks = block()
        if (tasks.isNotEmpty()) {
            val dependentTasks = mutableSetOf<String>()
            for (task in tasks) {
                dependentTasks.add(task.name)
            }
            this.dependentTasks = dependentTasks
            this.inDegree = this.dependentTasks.size
        }
        return this
    }
}

fun <T> on(vararg elements: T): Set<T> = if (elements.isNotEmpty()) elements.toSet() else emptySet()

XTaskProject

参考Anchors新增Project的定义，这样可以按项目的思维更灵活的定制我们的任务链。

/*
 * 任务项目，将一系列任务的集合当做一个任务工程来处理，这样每个功能模块都可以有自己的任务项目
 */
class XTaskProject(private val name: String) : IXTaskProject, XTaskLogger {

    /**
     * 为什么用map，利用Key-Value，判断同名的Task是否存在
     */
    private val taskMap = mutableMapOf<String, XTask>()

    /**
     * 为什么用List，因为需要对Task进行排序，可以说是空间换时间
     */
    private val taskList: MutableList<XTask> = mutableListOf()

    override fun addTask(task: XTask): IXTaskProject {
        //任务名称不能重复
        if (!taskMap.contains(task.name)) {
            logger.debug { "add Task $task" }
            taskMap[task.name] = task
        }
        return this
    }

    override fun getTasks(): List<XTask> {
        // 根据优先级排序，值小的先执行
        return taskList.apply {
            clear()
            addAll(ArrayList(taskMap.values))
            sortBy { it.priority }
        }
    }

    override fun release() {
        logger.debug { "release" }
        taskMap.clear()
        taskList.clear()
    }
}

interface IXTaskProject {

    fun addTask(task: XTask): IXTaskProject

    fun getTasks(): List<XTask>

    fun release()

}

XTaskStarter

任务启动器，主要是支持生成PlantUML Activity示意图。

package com.lonbon.lonbonxtask.core

import com.lonbon.lonbonxtask.core.logger.XTaskLogger
import com.lonbon.lonbonxtask.logger.PlantUMLCreator
import kotlinx.coroutines.*
import java.util.*

/*
 * *****************************************************************************
 * <p>
 * Copyright (C),2007-2016, LonBon Technologies Co. Ltd. All Rights Reserved.
 * <p>
 * *****************************************************************************
 * 任务启动器
 */
object XTaskStarter : XTaskLogger {

    /**
     * 开始执行project中的任务
     * runBlocking 会阻塞线程，如果是在主线程调用，则必须小心ANR
     * @param project IXTaskProject
     */
    @JvmStatic
    fun start(project: IXTaskProject) = runBlocking {
        //获取按优先级排序的列表
        val taskList: List<XTask> = project.getTasks()
        //缓存完成的任务
        val finishedTaskList: MutableList<XTask> = mutableListOf()
        // 找出所有入度为0的任务，加入到队列当中
        val queue: Queue<XTask> = LinkedList()
        taskList.filter { it.inDegree == 0 }.forEach(queue::add)
        //建立一个map, 通过name可以获取协程的Job
        val jobMap = mutableMapOf<String, Job>()
        //循环执行队列里的任务
        logger.info { "Start assigning tasks, current time ${System.currentTimeMillis()}" }
        var totalCostTime = 0L
        //添加第一个活动节点
        val plantUMLCreator = PlantUMLCreator()
        plantUMLCreator.reset()
        if (queue.size > 1) {
            val parallelTasks = mutableListOf<String>()
            for (task in queue) {
                parallelTasks.add(task.name)
            }
            plantUMLCreator.addParallelTask(parallelTasks)
        } else {
            queue.peek()?.let {
                plantUMLCreator.addSingleTask(it.name)
            }
        }
        while (queue.isNotEmpty()) {
            //获取当前需要执行的任务
            val currentTask = queue.poll()!!
            logger.info { "--- Current assigned task is $currentTask" }
            //在指定的协程调度器启动一个协程，并返回Job
            jobMap[currentTask.name] = launch(currentTask.coroutineDispatcher) {
                //遍历当前任务依赖的任务集合
                for (dependentTask in currentTask.dependentTasks) {
                    //使用给定的协程上下文调用指定的挂起块，挂起直到完成，并返回结果。
                    withContext(currentTask.coroutineDispatcher) { // 这句代码很重要，不然会有死锁，想一想为什么？
                        jobMap[dependentTask]!!.join() // 依赖的任务必须先执行完，因为这个是拓扑排序执行的，所以理论上jobMap[dep]不可能为空，当然有可能填错任务名称的
                    }
                }
                //依赖已经执行完成，执行自身的任务
                val startTime = System.currentTimeMillis()
                logger.info { ">>>>>> Task ${currentTask.name} start <<<<<<" }
                val intercept = currentTask.run()
                logger.info { "Task ${currentTask.name} notifyObservers $intercept" }
                val endTime = System.currentTimeMillis()
                val costTime = (endTime - startTime)
                totalCostTime += costTime
                logger.info { "<<<<<< Task ${currentTask.name} completed, cost $costTime ms >>>>>>" }
                //添加到任务完成集合
                finishedTaskList.add(currentTask)
                //通知观察者
                currentTask.notify(intercept)
                //更新节点耗时
                plantUMLCreator.getPlantUMLActivityNode(currentTask.name)?.let {
                    logger.info { "${currentTask.name} getPlantUMLActivityNode ${it.elements}" }
                    logger.info { "${currentTask.name} costTime $costTime" }
                    it.elements[currentTask.name]?.costTime = costTime
                }
                //如果拦截，则取消剩余未完成的job
                if (intercept) {
                    project.release()
                    queue.clear()
                    for ((taskName, job) in jobMap) {
                        if (job.isActive) {
                            job.cancel()
                            logger.info { "Task $taskName $job cancel" }
                        }
                    }
                    jobMap.clear()
                    logger.warn { "============ Task ${currentTask.name} intercept, clear queue and cancel all jobs " }
                }
                logger.info { "${currentTask.name} taskList size ${taskList.size}  finishedTaskList size ${finishedTaskList.size} " }
                if (taskList.size == finishedTaskList.size) {
                    logger.info { "All tasks completed cost $totalCostTime ms " }
                    //保存
                    logger.info { "All tasks completed cost $totalCostTime ms " }
                    plantUMLCreator.create()
                }
            }
            //当前任务已经开始分配，找到所有依赖当前任务的任务，将它们的入度减1，如果入度为0，则加入队列
            val toBeOfferTasks = mutableListOf<XTask>()
            //记录当前任务是否有被其它任务依赖
            var currentTaskHasDependentTasks = false
            for (task in taskList) {
                if (task.dependentTasks.contains(currentTask.name)) {
                    currentTaskHasDependentTasks = true
                    //入度减1
                    task.inDegree--
                    //入度为0，则进入队列
                    if (task.inDegree == 0) {
                        toBeOfferTasks.add(task)
                    }
                }
            }
            logger.info { "${currentTask.name} currentTaskHasDependentTasks $currentTaskHasDependentTasks toBeOfferTasks $toBeOfferTasks" }
            //修改任务end标记
            plantUMLCreator.getPlantUMLActivityNode(currentTask.name)?.apply {
                elements[currentTask.name]?.end = !currentTaskHasDependentTasks
            }
            //添加下一个活动节点
            if (toBeOfferTasks.isNotEmpty()) {
                if (toBeOfferTasks.size > 1) {
                    val parallelTasks = mutableListOf<String>()
                    for (task in toBeOfferTasks) {
                        parallelTasks.add(task.name)
                    }
                    logger.info { "${currentTask.name} addParallelTask $parallelTasks" }
                    plantUMLCreator.addParallelTask(parallelTasks)
                } else {
                    toBeOfferTasks[0].let {
                        logger.info { "${currentTask.name} addSingleTask ${it.name}" }
                        plantUMLCreator.addSingleTask(it.name)
                    }
                }
                //将入度为零的任务加入队列
                for (task in toBeOfferTasks) {
                    queue.offer(task)
                }
            }
        }
        // 这个地方需要判断一下，是否所有的任务都已经被安排执行了，如果还有任务没有被安排，说明任务存在循环依赖，抛出异常。
        if (taskList.isNotEmpty() && jobMap.isNotEmpty() && jobMap.size != taskList.size) {
            //循环结束后，如果有任务没有安排，则jobMap数量肯定是不等于taskList的数量
            throw Throwable("Exist Recycle Task!")
        }
        logger.info { "All task assignments completed" }
    }

}

PlantUMLCreator

PlantUMLCreator用于生成PlantUML Activity示意图。见：activity-diagram-beta

/*
 * 创建PlantUML 活动图（beta版）
 */
class PlantUMLCreator : XTaskLogger {

    companion object {
        private const val START_UML = "@startuml"
        private const val END_UML = "@enduml"
        private const val START = "start"
        private const val END = "end"
        private const val STOP = "stop"
        private const val FORK = "fork"
        private const val FORK_AGAIN = "fork again"
        private const val END_FORK = "end fork"
        private const val COLON = ":"
        private const val SEMI_COLON = ";"
        private const val LINE_BREAK = "\r\n"
    }

    /**
     * PlantUML内容
     */
    private var text: String = ""

    /**
     * 活动类，见https://plantuml.com/zh/activity-diagram-beta
     */
    private val activityDiagram = PlantUMLActivityDiagram()

    /**
     * 重置数据
     */
    fun reset() {
        activityDiagram.nodeDeque.clear()
    }

    private fun startUml() {
        text = START_UML + LINE_BREAK
    }

    private fun endUml() {
        text += END_UML + LINE_BREAK
    }

    private fun start() {
        text += START + LINE_BREAK
    }

    private fun stop() {
        text += STOP + LINE_BREAK
    }

    private fun end() {
        text += END + LINE_BREAK
    }

    private fun fork() {
        text += FORK + LINE_BREAK
    }

    private fun forkAgain() {
        text += FORK_AGAIN + LINE_BREAK
    }

    private fun endFork() {
        text += END_FORK + LINE_BREAK
    }

    private fun addActivityLabel(label: String) {
        text += COLON + label + SEMI_COLON + LINE_BREAK
    }

    /**
     * 根据任务名称获取指定的活动节点
     * @param taskName String
     * @return PlantUMLActivityNode?
     */
    fun getPlantUMLActivityNode(taskName: String): PlantUMLActivityNode? =
        activityDiagram.nodeMap[taskName]

    /**
     * 添加一个单线任务
     * @param taskName String
     */
    fun addSingleTask(taskName: String): PlantUMLActivityNode = PlantUMLActivityNode().apply {
        elements[taskName] = PlantUMLActivityNodeElement()
        activityDiagram.nodeDeque.add(this)
        activityDiagram.nodeMap[taskName] = this
        logger.info { "addSingleTask: $taskName $elements" }
    }

    /**
     * 添加并行任务
     * @param taskNameList List<String>
     */
    fun addParallelTask(taskNameList: List<String>): PlantUMLActivityNode =
        PlantUMLActivityNode().apply {
            logger.info { "addParallelTask: taskNameList $taskNameList" }
            for (taskName in taskNameList) {
                elements[taskName] = PlantUMLActivityNodeElement()
                activityDiagram.nodeMap[taskName] = this
            }
            activityDiagram.nodeDeque.add(this)
            logger.info { "addParallelTask: $taskNameList $elements" }
        }


    /**
     * 生成plantuml代码
     */
    fun create(): String {
        startUml()
        start()
        //logger.info { "create: node size is ${activityDiagram.nodeDeque.size}" }
        while (activityDiagram.nodeDeque.isNotEmpty()) {
            activityDiagram.nodeDeque.removeFirstOrNull()?.run {
                //logger.info { "create: node ${this.elements}" }
                if (elements.size == 1) {
                    for (ele in elements) {
                        logger.info { "create: element ${ele.key}" }
                        addActivityLabel("${ele.key} ${ele.value.costTime}ms")
                    }
                    return@run
                }
                var first = true
                for (ele in elements) {
                    if (first) {
                        first = false
                        fork()
                    } else {
                        forkAgain()
                    }
                    //logger.info { "create: element $ele" }
                    addActivityLabel("${ele.key} ${ele.value.costTime}ms")
                    if (ele.value.end) {
                        end()
                    }
                }
                endFork()
            }
        }
        stop()
        endUml()
        logger.info { "create: \n\n$text" }
        return text
    }

}


/**
 * 节点元素
 * @property end Boolean true没有被其它任务依赖
 * @property costTime Long 消耗时长（毫秒ms）
 * @constructor
 */
data class PlantUMLActivityNodeElement(var end: Boolean = false, var costTime: Long = 0L)

/**
 * PlantUML活动节点
 * @property elements MutableMap<PlantUMLActivityNodeElement, Boolean> Key->Value:节点元素->结束标志
 */
class PlantUMLActivityNode {
    val elements = mutableMapOf<String, PlantUMLActivityNodeElement>()
}

/**
 * PlantUML活动示意图类
 * @property nodeDeque Deque<PlantUMLActivityNode> 双端队列
 * @property nodeMap Deque<PlantUMLActivityNode> map方便获取Node节点
 */
class PlantUMLActivityDiagram {
    val nodeDeque: ArrayDeque<PlantUMLActivityNode> = ArrayDeque()
    val nodeMap = mutableMapOf<String, PlantUMLActivityNode>()
}

线程调度

原本的线程调度是通过Task中的mainThread属性来判断是否需要在主线程中调用，这样有一个不好的地方就是不能指定任务的调度线程，也不方便做单元测试，改成可指定CoroutineDispatcher自由度会更高一些。

代码如下：

data class XTask(
    val name: String,//任务名称，不可以重复
    val desc: String = "",//任务描述
    val coroutineDispatcher: CoroutineDispatcher = Dispatchers.Default,//线程调度
    val priority: Int = 0,   // 运行的优先级，值小的先执行
    var dependentTasks: Set<String> = kotlin.collections.setOf(), // 依赖的任务集合(不可重复，所以用Set)
    val run: suspend () -> Boolean = { false }, //具体的执行任务的函数，为什么放在构造函数，主要是方便全局查看任务。返回是否拦截
)

默认为Dispatchers.Default，在Android中如果需要在主线程运行，可以指定为Dispatchers.Main。

在本地单元测试中，封装 Android UI线程的Dispatchers.Main是无法使用的，因为我们执行的单元测试是在本地 JVM中，并不是在 Android 设备上。如果被测试代码使用了Dispatchers.Main，那么单元测试就会在运行过程中抛出异常。

注意：这种情况只会发生于本地单元测试。在可使用真实界面线程的插桩测试中，不应该替换 Main 调度程序。

如果需要在所有情况下都将 Dispatchers.Main调度程序替换为 TestDispatcher，则可以使用 Dispatchers.setMain 和 Dispatchers.resetMain 函数。

代码示例：

@Test
fun settingMainDispatcher() = runTest {
    val testDispatcher = UnconfinedTestDispatcher(testScheduler)
    Dispatchers.setMain(testDispatcher)
    try {
        val viewModel = HomeViewModel()
        viewModel.loadMessage() // Uses testDispatcher, runs its coroutine eagerly
        assertEquals("Greetings!", viewModel.message.value)
    } finally {
        Dispatchers.resetMain()
    }
}

更多关于协程的单元测试内容参考：在 Android 上测试 Kotlin 协程

一个完整的单元测试用例如下：

/**
 * Example local unit test, which will execute on the development machine (host).
 *
 * See [testing documentation](http://d.android.com/tools/testing).
 */
class ExampleUnitTest {

    @Test
    fun testXTask() = runTest(UnconfinedTestDispatcher()) {
        val project = XTaskProject("NormalProject")
        project.addTask(XTask(
            name = "TaskStart", coroutineDispatcher = Dispatchers.Default
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskA",
            coroutineDispatcher = Dispatchers.Default,
            dependentTasks = setOf("TaskStart")
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskB",
            coroutineDispatcher = Dispatchers.Default,
            dependentTasks = setOf("TaskStart")
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskC",
            coroutineDispatcher = Dispatchers.Default,
            dependentTasks = setOf("TaskStart")
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskD",
            coroutineDispatcher = Dispatchers.Default,
            dependentTasks = setOf("TaskA", "TaskC")
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskE",
            coroutineDispatcher = Dispatchers.Default,
            dependentTasks = setOf("TaskD")
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskF",
            coroutineDispatcher = Dispatchers.Default,
            dependentTasks = setOf("TaskD")
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskG",
            coroutineDispatcher = Dispatchers.Default,
            dependentTasks = setOf("TaskD")
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskH",
            coroutineDispatcher = Dispatchers.Default,
            dependentTasks = setOf("TaskF", "TaskG")
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskI",
            coroutineDispatcher = Dispatchers.Default,
            dependentTasks = setOf("TaskH")
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskJ",
            coroutineDispatcher = Dispatchers.Default,
            dependentTasks = setOf("TaskI")
        ) {
            delay(1000)
            false
        }).addTask(XTask(
            name = "TaskK",
            coroutineDispatcher = Dispatchers.Default,
        ) {
            delay(4000)
            false
        })
        XTaskManager.start(project)
    }

}

需要的注意是，当我们在本地单元测试中执行协程时，最好配合runTest和UnconfinedTestDispatcher来使用，否则无法立即执行协程。

runTest(UnconfinedTestDispatcher()) {
    //launch
}

任务优先级

有一些任务虽然是并行的，但是我们仍然希望这些任务有一个优先级，因此笔者加了个priority来对任务进行排序，priority值小的先执行。

override fun getTasks(): List<XTask> {
    // 根据优先级排序，值小的先执行
    return taskList.apply {
        clear()
        addAll(ArrayList(taskMap.values))
        sortBy { it.priority }
    }
}

注意，实际上优先级是对入度一样的任务才有效。并不是指所有任务的执行先后的优先级，也不是线程的优先级。

任务拦截

需求是多样化的，实际我们可能有这样的场景，比如网络不通或者不需要进行数据同步时，之后的任务链就不用执行了，因此需要增加拦截机制，提前结束后续的任务链。

因为所有的任务都是通过协程执行并返回job的对象，因此，想要进行拦截，就可以通过执行job.cancel来完成。当然，我们还需一个触发条件，笔者是通过任务返回值来判断是否需要进行拦截的。

代码如下：

val run: suspend () -> Boolean = { false }, //具体的执行任务的函数，为什么放在构造函数，主要是方便全局查看任务。返回是否拦截

val intercept = currentTask.run()
...省略若干代码....
//如果拦截，则取消剩余未完成的job
if (intercept) {
    project.release()
    queue.clear()
    for ((taskName, job) in jobMap) {
        if (job.isActive) {
            job.cancel()
            logger.info { "Task $taskName $job cancel" }
        }
    }
    jobMap.clear()
    logger.warn { "============ Task ${currentTask.name} intercept, clear queue and cancel all jobs " }
}

但是，如果协程里面又运行了协程怎么办？套娃呢。嗯，这个确实不好处理。因此，笔者强烈不建议这样写代码，我们应该通过拆分代码，定义新的任务和依赖关系来实现我们的需求。

可能还会有这样的需求，比如TaskB依赖TaskA，但是TaskB是否执行依赖于TaskA的结果，其它的Task则不受干扰。

面对这样的需求，可能就需要任务之间进行数据传递，就像RxJava那样，TaskA把结果给到TaskB，TaskB发现不满足条件就不执行对应的代码。或者简单点，Task增加一个是否可运行的标记位，当TaskA执行完后根据需要去设置TaskB的标记位，TaskB判断标记位不满足则不执行对应的代码。

总之如果要按上面的需求做一个精细化的控制，还是有蛮多工作要做的，这样会让整个逻辑变得更加复杂，调试起来会难上加难。实际上，笔者认为更简单更合理的方式，应该是将需求拆分，分成不同的Project来处理。如果Project之间有依赖关系，比如有ProjectA和ProjectB，ProjectB必须在ProjectA的TaskA之后才能开始，那么我们就可以给Task设计一个任务完成通知或者说增加一个锚点，这样ProjectB就可以在收到TaskA任务完成通知或到达锚点后开始执行。

任务完成通知

任务完成通知可以使用观察者模式，但如果需求简单，其实一个任务回调就基本满足需求了。

data class XTask(
    val name: String,//任务名称，不可以重复
    val desc: String = "",//任务描述
    val coroutineDispatcher: CoroutineDispatcher = Dispatchers.Default,//线程调度
    val priority: Int = 0,   // 运行的优先级，值小的先执行,
    var dependentTasks: Set<String> = setOf(), // 依赖的任务集合(不可重复，所以用Set)
    val run: suspend () -> Boolean = { false }, //具体的执行任务的函数，为什么放在构造函数，主要是方便全局查看任务。返回是否拦截
) : Observable() {
    // 入度，用于有向无环图的拓扑排序
    var inDegree = dependentTasks.size

    /**
     * 通知通知观察者
     */
    fun notify(arg: Any) {
        setChanged()
        notifyObservers(arg)
    }
}
//添加观察者
val taskA = XTask(
    name = "TaskA",
    coroutineDispatcher = Dispatchers.Default,
) {
    delay(1000)
    false
}.apply {
    addObserver { _, arg ->
        println("$name update intercept $arg")
    }
}

//依赖已经执行完成，执行自身的任务
val intercept = currentTask.run()
...省略若干代码
//通知观察者
currentTask.notify(intercept)

使用Kotlin DSL进行任务编排

原本的写法，任务的创建和任务之间依赖关系的定义是捆绑在一起的，这样有个不好的地方就是，任务之间的依赖关系不太直观，而且如果要改依赖关系也不太方便。实际上，我们还可以提供新的任务编排方式，将任务的创建和任务之间的依赖关系分开。

首先创建任务并添加进Project：

val diagramProject = XTaskProject("DiagramProject")
val taskStart = XTask(
    name = "TaskStart", coroutineDispatcher = Dispatchers.Default
) {
    delay(1000)
    false
}
val taskA = XTask(
    name = "TaskA",
    coroutineDispatcher = Dispatchers.Default,
) {
    delay(1000)
    false
}
val taskB = XTask(
    name = "TaskB",
    coroutineDispatcher = Dispatchers.Default,
) {
    delay(1000)
    false
}
val taskC = XTask(
    name = "TaskC",
    coroutineDispatcher = Dispatchers.Default,
) {
    delay(1000)
    false
}
val taskEnd = XTask(
    name = "TaskEnd", coroutineDispatcher = Dispatchers.Default
) {
    delay(1000)
    false
}
//添加进Project
diagramProject.apply {
    addTask(taskStart)
    addTask(taskA)
    addTask(taskB)
    addTask(taskC)
    addTask(taskEnd)
}

使用Kotlin DSL任务编排：

/**
 * <- 表示左边的任务依赖于右边的任务，即做的任务必须等右边的任务执行完毕之后才能执行
 * taskEnd <- taskB <- taskA <-taskStar
 * taskEnd <- taskC <- taskA
 */
taskEnd.depends {
    on(
        taskB.depends {
            on(
                taskA.depends {
                    on(taskStart)
                }
            )
        },
        taskC.depends {
            on(taskA)
        },
    )
}

使用Kotlin中缀函数美化一下代码：


taskEnd depends on(
    taskB depends on(
        taskA depends on(
            taskStart
        )
    ),
    taskC depends on(taskA)
)

奇奇怪怪的代码，不过倒是可以看得清楚任务之间的依赖关系。

执行下任务并看下结果：

任务的执行的先后顺序以及耗时一目了然，改成TaskEnd不依赖TaskC：

可以看到TaskC没有链接到TaskEnd，说明TaskEnd不依赖TaskC。

任务执行结果可视化

可能有人会好奇上面的图是怎么生成的，手动用画图软件画的？当然不是！利用plantuml可以帮助我们通过代码来画图。笔者使用的是plantuml的活动图(新语法)来表示任务执行的耗时和任务之间的依赖关系，当然，如果大家有更好的建议，非常欢迎一起交流。

活动图(新语法)的语法就不多说了，不了解的小伙伴点上面的链接先学习下。

如下图所示，通过一段代码可以生成对应的图。

这样一来，我们只需要关心怎么生成这段表示图的代码就可以了，不过前提是，你得了解它的语法吧。

代码如下：


/*
 * 创建PlantUML 活动图（beta版）
 */
class XTaskPlantUMLCreator : XTaskLogger {

    companion object {
        private const val START_UML = "@startuml"
        private const val END_UML = "@enduml"
        private const val START = "start"
        private const val END = "end"
        private const val STOP = "stop"
        private const val FORK = "fork"
        private const val FORK_AGAIN = "fork again"
        private const val END_FORK = "end fork"
        private const val COLON = ":"
        private const val SEMI_COLON = ";"
        private const val LINE_BREAK = "\r\n"
    }

    /**
     * PlantUML内容
     */
    private var text: String = ""

    /**
     * 活动类，见https://plantuml.com/zh/activity-diagram-beta
     */
    private val activityDiagram = PlantUMLActivityDiagram()

    /**
     * 重置数据
     */
    fun reset() {
        activityDiagram.nodeDeque.clear()
    }

    private fun startUml() {
        text = START_UML + LINE_BREAK
    }

    private fun endUml() {
        text += END_UML + LINE_BREAK
    }

    private fun start() {
        text += START + LINE_BREAK
    }

    private fun stop() {
        text += STOP + LINE_BREAK
    }

    private fun end() {
        text += END + LINE_BREAK
    }

    private fun fork() {
        text += FORK + LINE_BREAK
    }

    private fun forkAgain() {
        text += FORK_AGAIN + LINE_BREAK
    }

    private fun endFork() {
        text += END_FORK + LINE_BREAK
    }

    private fun addActivityLabel(label: String) {
        text += COLON + label + SEMI_COLON + LINE_BREAK
    }

    /**
     * 根据任务名称获取指定的活动节点
     * @param taskName String
     * @return PlantUMLActivityNode?
     */
    fun getPlantUMLActivityNode(taskName: String): PlantUMLActivityNode? =
        activityDiagram.nodeMap[taskName]

    /**
     * 添加一个单线任务
     * @param taskName String
     */
    fun addSingleTask(taskName: String): PlantUMLActivityNode = PlantUMLActivityNode().apply {
        elements[taskName] = PlantUMLActivityNodeElement()
        activityDiagram.nodeDeque.add(this)
        activityDiagram.nodeMap[taskName] = this
        logger.info { "addSingleTask: $taskName $elements" }
    }

    /**
     * 添加并行任务
     * @param taskNameList List<String>
     */
    fun addParallelTask(taskNameList: List<String>): PlantUMLActivityNode =
        PlantUMLActivityNode().apply {
            logger.info { "addParallelTask: taskNameList $taskNameList" }
            for (taskName in taskNameList) {
                elements[taskName] = PlantUMLActivityNodeElement()
                activityDiagram.nodeMap[taskName] = this
            }
            activityDiagram.nodeDeque.add(this)
            logger.info { "addParallelTask: $taskNameList $elements" }
        }


    /**
     * 生成plantuml代码
     */
    fun create(): String {
        startUml()
        start()
        //logger.info { "create: node size is ${activityDiagram.nodeDeque.size}" }
        while (activityDiagram.nodeDeque.isNotEmpty()) {
            activityDiagram.nodeDeque.removeFirstOrNull()?.run {
                //logger.info { "create: node ${this.elements}" }
                if (elements.size == 1) {
                    for (ele in elements) {
                        logger.info { "create: element ${ele.key}" }
                        addActivityLabel("${ele.key} ${ele.value.costTime}ms")
                    }
                    return@run
                }
                var first = true
                for (ele in elements) {
                    if (first) {
                        first = false
                        fork()
                    } else {
                        forkAgain()
                    }
                    //logger.info { "create: element $ele" }
                    addActivityLabel("${ele.key} ${ele.value.costTime}ms")
                    if (ele.value.end) {
                        end()
                    }
                }
                endFork()
            }
        }
        stop()
        endUml()
        logger.info { "create: \n\n$text" }
        return text
    }

}


/**
 * 节点元素
 * @property end Boolean true没有被其它任务依赖
 * @property costTime Long 消耗时长（毫秒ms）
 * @constructor
 */
data class PlantUMLActivityNodeElement(var end: Boolean = false, var costTime: Long = 0L)

/**
 * PlantUML活动节点
 * @property elements MutableMap<PlantUMLActivityNodeElement, Boolean> Key->Value:节点元素->结束标志
 */
class PlantUMLActivityNode {
    val elements = mutableMapOf<String, PlantUMLActivityNodeElement>()
}

/**
 * PlantUML活动示意图类
 * @property nodeDeque Deque<PlantUMLActivityNode> 双端队列
 * @property nodeMap Deque<PlantUMLActivityNode> map方便获取Node节点
 */
class PlantUMLActivityDiagram {
    val nodeDeque: ArrayDeque<PlantUMLActivityNode> = ArrayDeque()
    val nodeMap = mutableMapOf<String, PlantUMLActivityNode>()
}

也没什么技巧，直接拼接就完事了。有了这段代码，我们就可以在任务执行的过程中，根据依赖关系，执行耗时，调用相关的方法来填充需要的信息。

需要注意的，最终我们只生成了需要的代码，如果要转成图片，需要通过plantuml网站或者下载它们提供的jar包来操作。参考：plantuml入门指南。