写点什么

一线大厂大型 APP 性能优化系列 - 自定义启动器(三),整理出 Android 逆向系列学习进阶视频

用户头像
Android架构
关注
发布于: 2021 年 11 月 05 日

Runnable getTailRunnable();


/**


  • Task 执行过程中的回调*/void setTaskCallBack(TaskCallBack callBack);}


好了,这些基本够用了。

2.实现 task 接口

public abstract class Task implements ITask {


private volatile boolean mIsWaiting; // 是否正在等待 private volatile boolean mIsRunning; // 是否正在执行 private volatile boolean mIsFinished; // Task 是否执行完成 private volatile boolean mIsSend; // Task 是否已经被分发


// 当前 Task 依赖的 Task 数量(需要等待被依赖的 Task 执行完毕才能执行自己),默认没有依赖 private CountDownLatch mDepends = new CountDownLatch(dependsOn() == null ? 0 : dependsOn().size());


/**


  • 依赖的 Task 执行完一个*/public void satisfy() {mDepends.countDown();}


/**


  • 当前 Task 等待,让依赖的 Task 先执行*/public void waitToSatisfy() {try {mDepends.await();} catch (InterruptedException e) {e.printStackTrace();}}


/**


  • 异步线程执行的 Task 是否需要在被调用 await 的时候等待(也就是是否需要主线程等你执行完再执行),默认不需要

  • @return*/@Overridepublic boolean needWait() {return false;}


/**


  • 当前 Task 依赖的 Task 集合(需要等待被依赖的 Task 执行完毕才能执行自己),默认没有依赖

  • @return*/@Overridepublic List<Class<? extends Task>> dependsOn() {return null;}}


很简单,主要做的是:1.根据 dependsOn() 定义一个栅栏


很好理解,传入的 task(我们的耗时任务),因为


《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
浏览器打开:qq.cn.hn/FTe 免费领取
复制代码


需要依赖,比如 TaskA,必须得等 TaskB,TaskC 加载完毕才能加载 TaskA,那么 dependsOn()返回的就是 TaskB,TaskC,也就是在 TaskA 中加了几个同步锁(锁的数量就是 TaskA 所需要依赖的 Task 数量),每次执行 satisfy()就减少一把锁。

3.实现启动器

外部调用


TaskDispatcher instance = TaskDispatcher.createInstance();instance.addTask(new InitBuglyTask()) // 默认添加,并发处理.addTask(new InitBaiduMapTask()) // 在这里需要先处理了另外一个耗时任务 initShareSDK,才能再处理它.addTask(new InitJPushTask()) // 等待主线程处理完毕,再进行执行.start();instance.await();


构建启动器


public class TaskDispatcher {


private static Context mContext;private static boolean sHasInit;private static boolean sIsMainProcess;


// 存放依赖 private HashMap<Class<? extends Task>, ArrayList<Task>> mDependedHashMap = new HashMap<>();


// 存放所有的 taskprivate List<Task> mAllTasks = new ArrayList<>();private List<Class<? extends Task>> mClsAllTasks = new ArrayList<>();


// 调用了 await 的时候还没结束的且需要等待的 Task 队列 private List<Task> mNeedWaitTasks = new ArrayList<>();


// 已经结束了的 Task 队列 private volatile List<Class<? extends Task>> mFinishedTasks = new ArrayList<>(100);


// 需要在主线程中执行的 Task 队列 private volatile List<Task> mMainThreadTasks = new ArrayList<>();


// 保存需要 Wait 的 Task 的数量 private AtomicInteger mNeedWaitCount = new AtomicInteger();private CountDownLatch mCountDownLatch;


/**


  • 注意:每次获取的都是新对象*/public static TaskDispatcher getInstance(Context context) {


if (context != null) {mContext = context;sHasInit = true;sIsMainProcess = Utils.isMainProcess(mContext);}return new TaskDispatcher();}


/**


  • 添加任务*/public TaskDispatcher addTask(Task task) {


if (task != null) {


// ->> 1collectDepends(task);


// ->> 2mAllTasks.add(task);mClsAllTasks.add(task.getClass());// ->> 3if (ifNeedWait(task)) {mNeedWaitTasks.add(task);mNeedWaitCount.getAndIncrement();}}return this;}


/**


  • 存放相关依赖信息

  • */private void collectDepends(Task task) {


// 如果存在依赖 if (task.dependsOn() != null && task.dependsOn().size() > 0) {


// 获取依赖 for (Class<? extends Task> cls : task.dependsOn()) {if (mDependedHashMap.get(cls) == null) {mDependedHashMap.put(cls, new ArrayList<Task>());}mDependedHashMap.get(cls).add(task);if (mFinishedTasks.contains(cls)) {task.satisfy();}}}}


/**


  • task 是否需要主线程等其完成再执行

  • */private boolean ifNeedWait(Task task) {return !task.runOnMainThread() && task.needWait();}


@UiThreadpublic void start() {


if (Looper.getMainLooper() != Looper.myLooper()) {throw new RuntimeException("小子,启动器必须要在主线程启动");}if (mAllTasks.size() > 0) {


// 4.->> 查看被依赖的信息 printDependedMsg();


// 5.->> 拓扑排序并返回 mAllTasks = TaskSortUtil.getSortResult(mAllTasks, mClsAllTasks);


// 6.->> 构建同步锁 mCountDownLatch = new CountDownLatch(mNeedWaitCount.get());


// 7.->> 分发 taskdispatchTasks();executeTaskMain();}}


/**


  • 查看被依赖的信息*/private void printDependedMsg() {DispatcherLog.i("needWait size : " + (mNeedWaitCount.get()));if (false) {for (Class<? extends Task> cls : mDependedHashMap.keySet()) {DispatcherLog.i("cls " + cls.getSimpleName() + " " + mDependedHashMap.get(cls).size());for (Task task : mDependedHashMap.get(cls)) {DispatcherLog.i("cls " + task.getClass().getSimpleName());}}}}


/**


  • task 分发,根据设定的不同规则,分发到不同的线程*/private void dispatchTasks() {for (Task task : mAllTasks) {


if (task.runOnMainThread()) {mMainThreadTasks.add(task);


if (task.needCall()) {task.setTaskCallBack(new TaskCallBack() {@Overridepublic void call() {


TaskStat.markTaskDone();task.setFinished(true);satisfyChildren(task);markTaskDone(task);}});}} else {// 异步线程中执行,是否执行取决于具体线程池 Future future = task.runOn().submit(new DispatchRunnable(task,this));mFutures.add(future);}}


/**


  • 从等待队列中移除,添加进结束队列*/public void markTaskDone(Task task) {


// 8 ->>if (ifNeedWait(task)) {mFinishedTasks.add(task.getClass());mNeedWaitTasks.remove(task);mCountDownLatch.countDown();mNeedWaitCount.getAndDecrement();}}


private void executeTaskMain() {mStartTime = System.currentTimeMillis();for (Task task : mMainThreadTasks) {long time = System.currentTimeMillis();new DispatchRunnable(task,this).run();}}


首先是通过 getInstance()构造了一个实例对象,然后通过 addTask() 添加我们的 Task, 如果它不为空的话


根据上面的角标,逐一介绍


  1. 调用 collectDepends(),遍历该 task 所依赖的全部 task,并且以它所依赖的 task 为 Key, 本身为 Value 中集合元素的一员添加进去,然后判断,该 task 中的依赖是否已经加载过了,如果加载过了,调用该 task 的 satisfy()方法减该 task 的一把锁。

  2. 然后将这个 task 和它的 class 文件添加到 2 个集合中,方便后面使用。

  3. 如果该 Task 需要主线程等其完成再执行的话,则添加到等待队列中,等待队列计数器+1

  4. 打印该 task 所依赖的信息

  5. 拓扑排序,经典的算法,用于描述依赖关系的排序,在上一章节有过介绍也给出过源码,这里就不再赘述

  6. 这里实际上就是构建一把锁,这个锁注意并不在 Task 里面,Task 里面的锁,注意是为了先执行依赖的 Task,执行完毕,再执行自己,而这里的锁是在启动器上,其作用是让主线程等待,优先执行那些必须要先执行完毕才能让主线程继续执行完毕,再跳转页面的 task

用户头像

Android架构

关注

还未添加个人签名 2021.10.31 加入

还未添加个人简介

评论

发布
暂无评论
一线大厂大型APP性能优化系列-自定义启动器(三),整理出Android逆向系列学习进阶视频