2024年一线大厂大型APP性能优化系列-自定义启动器（三），海尔 面试

最后

我坚信，坚持学习，每天进步一点，滴水穿石，我们离成功都很近！
以下是总结出来的字节经典面试题目，包含：计算机网络，Kotlin，数据结构与算法，Framework源码，微信小程序，NDK音视频开发，计算机网络等。

字节高级Android经典面试题和答案

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

.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> mDependedHashMap = new HashMap<>();

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

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

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

// 需要在主线程中执行的Task队列
private volatile List 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) {

// ->> 1
collectDepends(task);

// ->> 2
mAllTasks.add(task);
mClsAllTasks.add(task.getClass());
// ->> 3
if (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());
}
mDependedHashMap.get(cls).add(task);
if (mFinishedTasks.contains(cls)) {
task.satisfy();
}
}
}
}

/**

• task 是否需要主线程等其完成再执行
• */
  private boolean ifNeedWait(Task task) {
  return !task.runOnMainThread() && task.needWait();
  }

@UiThread
public 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.->> 分发task
dispatchTasks();
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() {
@Override
public 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
7. 根据需要分发不同的线程去执行，如果是需要在主线程中执行，那就先存储起来，如果是需要在一部现场中执行，那就直接调用task.runOn()方法来异步执行耗时task，runOn()可复写，不写为默认线程池
8. 如果该线程需要在主线程中执行，将它从等待队列中移除，添加进结束队列，如果该task需要主线程等待的话，主线程的同步锁-1，等待队列数-1

4.DispatchRunnable的实现

好了如何执行任务尼？

public class DispatchRunnable implements Runnable {
private Task mTask;
private TaskDispatcher mTaskDispatcher;

public DispatchRunnable(Task task) {
this.mTask = task;
}
public DispatchRunnable(Task task,TaskDispatcher dispatcher) {
this.mTask = task;
this.mTaskDispatcher = dispatcher;
}

@Override
public void run() {

Process.setThreadPriority(mTask.priority());

long startTime = System.currentTimeMillis();

mTask.setWaiting(true);
mTask.waitToSatisfy();

long waitTime = System.currentTimeMillis() - startTime;
startTime = System.currentTimeMillis();

// 执行Task
mTask.setRunning(true);
mTask.run();

// 执行Task的尾部任务
Runnable tailRunnable = mTask.getTailRunnable();
if (tailRunnable != null) {
tailRunnable.run();
}

if (!mTask.needCall() || !mTask.runOnMainThread()) {
printTaskLog(startTime, waitTime);

TaskStat.markTaskDone();
mTask.setFinished(true);
if(mTaskDispatcher != null){
mTaskDispatcher.satisfyChildren(mTask);

// --> 8
mTaskDispatcher.markTaskDone(mTask);
}
}
TraceCompat.endSection();
}
}
复制代码

好了，是不是很简单？ 优先执行需要依赖的Task, 然后再执行自己，等都执行完毕后，调用mTaskDispatcher.markTaskDone(mTask); 将该task从等待队列中移除，添加进结束队列，如果该task需要主线程等待的话，主线程的同步锁-1，等待队列数-1

再看下我们自己的task

public class InitJPushTask extends Task {

@Override
public boolean needWait() {
return true;
}

@Override
public List<Class<? extends Task>> dependsOn() {
List<Class<? extends Task>> tasks = new ArrayList<>();
tasks.add(GetDeviceIdTask.class);
return tasks;
}

作者2013年从java开发，转做Android开发，在小厂待过，也去过华为，OPPO等大厂待过，18年四月份进了阿里一直到现在。

参与过不少面试，也当面试官 面试过很多人。深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长，不成体系的学习效果低效漫长，而且极易碰到天花板技术停滞不前！

我整理了一份阿里P7级别的最系统的Android开发主流技术，特别适合有3-5年以上经验的小伙伴深入学习提升。

主要包括阿里，以及字节跳动，腾讯，华为，小米，等一线互联网公司主流架构技术。如果你想深入系统学习Android开发，成为一名合格的高级工程师，可以收藏一下这些Android进阶技术选型

我搜集整理过这几年阿里，以及腾讯，字节跳动，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 Xmind（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。

Java语言与原理；
大厂，小厂。Android面试先看你熟不熟悉Java语言

高级UI与自定义view；
自定义view，Android开发的基本功。

性能调优；
数据结构算法，设计模式。都是这里面的关键基础和重点需要熟练的。

NDK开发；
未来的方向，高薪必会。

前沿技术；
组件化，热升级，热修复，框架设计

网上学习 Android的资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。希望这份系统化的技术体系对大家有一个方向参考。

我在搭建这些技术框架的时候，还整理了系统的高级进阶教程，会比自己碎片化学习效果强太多，CodeChina上可见；

当然，想要深入学习并掌握这些能力，并不简单。关于如何学习，做程序员这一行什么工作强度大家都懂，但是不管工作多忙，每周也要雷打不动的抽出 2 小时用来学习。

不出半年，你就能看出变化！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！

可见；

当然，想要深入学习并掌握这些能力，并不简单。关于如何学习，做程序员这一行什么工作强度大家都懂，但是不管工作多忙，每周也要雷打不动的抽出 2 小时用来学习。

不出半年，你就能看出变化！

网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。

需要这份系统化学习资料的朋友，可以戳这里获取

一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！