App啟動(dòng)優(yōu)化-基于有向無環(huán)圖的sdk初始化方案
2021-09-24 14:41:41

class Application{
   ...

   onCreate(){
       initSDKA();
       initSDKB();
       initSDKC();
       ....
   }

   ...
}

public abstract class TaskNode implements Runnable,ITask {

        public short inDegree; // 當(dāng)前 Task 在有向圖中的入度，用于判斷圖中是否有環(huán)
        HashSet<TaskNode> nextList = new HashSet<>(); // 后繼節(jié)點(diǎn)
        List<TaskNode> depended = new ArrayList<>(); 

        OnTaskResult onTaskResult;
}

    /**
     * 生成有向圖
    */
    private void generateGraph() {
        for (TaskNode taskNode : taskNodes) {
            // 如果該節(jié)點(diǎn)沒有任何依賴關(guān)系，則直接掛載在 root 下
            if (getPreNodes(taskNode) == null || getPreNodes(taskNode).size() == 0) {
                root.nextList.add(taskNode);
                // 計(jì)算入度
                taskNode.inDegree = 1;
            } else {
                short inDegree = 0;
                List<TaskNode> taskNodeList = getPreNodes(taskNode);
                // 如果該節(jié)點(diǎn)有依賴關(guān)系，則掛載在依賴的Task 之后
                for (TaskNode preNode : taskNodeList) {
                    preNode.nextList.add(taskNode);
                    inDegree++;
                }
                // 計(jì)算入度
                taskNode.inDegree = inDegree;
            }
        }
    }

    /**
     * 獲取該節(jié)點(diǎn)依賴的節(jié)點(diǎn)的集合
     * @param taskNode
     * @return
     */
    private List<TaskNode> getPreNodes(TaskNode taskNode) {
        if (taskNode.depended.isEmpty()) {
            return null;
        }
        List<TaskNode> taskNodeList = new ArrayList<>();
        for (TaskNode clazz : taskNode.depended) {
            taskNodeList.add(node);
        }
        return taskNodeList;
    }

/**
 * 判斷圖中是否有環(huán)
 * 
 */
private void isThereARing() {
    // 臨時(shí)棧，用于存放入度為0的節(jié)點(diǎn)
    Stack<TaskNode> nodeStack = new Stack<>();
    nodeStack.push(root);

    // 存放拓補(bǔ)排序排序的集合
    ArrayList<TaskNode> topologicalSort = new ArrayList<>();
    while (!nodeStack.isEmpty()) {
        TaskNode taskNode = nodeStack.pop();
        topologicalSort.add(taskNode);
        if (taskNode.nextList.size() != 0) {
            for (TaskNode nextNode : taskNode.nextList) {
                // 當(dāng)前節(jié)點(diǎn)指向下一節(jié)點(diǎn)，將下一節(jié)點(diǎn)的入度 減1
                nextNode.inDegree--;
                // 如果下一節(jié)點(diǎn)的入度是0，將入度為 0 的節(jié)點(diǎn)入棧，用于下一次遍歷
                if (nextNode.inDegree == 0) {
                    nodeStack.push(nextNode);
                }
            }
        }
    }

    // 拋出異常中斷程序異常信息中提示 存在環(huán)的相關(guān) Task
    if (taskCount != topologicalSort.size()) {
        taskNodes.removeAll(topologicalSort);
        StringBuilder builder = new StringBuilder();
        builder.append(" [");
        for (TaskNode taskNode : taskNodes) {
            builder.append(taskNode.getClass().getSimpleName());
            builder.append(",");
        }
        builder.append(" ]");
        throw new RuntimeException("there is a ring among" + builder.toString());
    }
}

runTask(root); // 開始遍歷
waitMain();

private void runTask(final TaskNode taskNode) {
    // 只有入度為0的節(jié)點(diǎn)才能開始運(yùn)行
    if (taskNode.backupInDegree.get() == 0) {
        // 當(dāng)前Task運(yùn)行完成回掉
        taskNode.setOnTaskResult(new OnTaskResult() {
            @Override
            public void OnTaskEnd(HashSet<TaskNode> nextList) {
                // 遍歷結(jié)束條件，尾節(jié)點(diǎn)遍歷完成
                if (taskNode instanceof TaskTail) {
                    return;
                }

                // 尋找下一節(jié)點(diǎn)，嘗試運(yùn)行。
                for (TaskNode nextNode : taskNode.nextList) {
                    // 遞減入度，直到為0的時(shí)候，該Task 才可以執(zhí)行
                    nextNode.backupInDegree.decrementAndGet(); 
                    runTask(nextNode);
                }
            }
        });

        if (taskNode.isMainThread()) {
            // 主線程任務(wù)放入消費(fèi)隊(duì)列，由主線程消費(fèi)
            try {
               // 阻塞隊(duì)列，會(huì)阻塞主線程 
               // blockingQueueMain = new ArrayBlockingQueue<TaskNode>();
               blockingQueueMain.put(taskNode);
            } catch (InterruptedException e) {
               e.printStackTrace();
            }
        } else {
            // 子線程任務(wù)直接由線程池運(yùn)行
            executorService.execute(taskNode);
        }
    }
}

/**
 * 遍歷開始時(shí)，主線程阻塞，直到尾節(jié)點(diǎn)遍歷結(jié)束。
 */
private void waitMain() {
    long startTime = SystemClock.uptimeMillis();
    // 超時(shí)邏輯，防止主線程阻塞超時(shí)
    while (SystemClock.uptimeMillis() - startTime < timeOut) {
        try {
            TaskNode taskNode = blockingQueueMain.poll(timeOut, TimeUnit.MILLISECONDS);
            taskNode.run();
            // 到達(dá)尾節(jié)點(diǎn)直接跳出循環(huán)，放開主線程
            if (taskNode instanceof TaskTail) {
                break;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

    class Application{
       ...

        onCreate(){
            new TaskA().run();
            new TaskC().run();
            new TaskB().run();
            new TaskD().run();
            new TaskE().run();
             ....
        }

        ...
    }

TasksManager.getInstance(this).addTask(new TaskA())
              .addTask(new TaskB())
              .addTask(new TaskC())
              .addTask(new TaskC())
              .addTask(new TaskE()).start();