2024年安卓最全Android 启动优化（四）- AnchorTask 是怎么实现的(2)，C++多线程面试题

最后

都说三年是程序员的一个坎，能否晋升或者提高自己的核心竞争力，这几年就十分关键。

技术发展的这么快，从哪些方面开始学习，才能达到高级工程师水平，最后进阶到Android架构师/技术专家？我总结了这 5大块；

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

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

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

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

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

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

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

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

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

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

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

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

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

3. 多线程当中，等待和唤醒功能，有多种方式可以实现。wait、notify 机制，ReentrantLock Condition 机制，CountDownLatch 机制。这里我们选择 CountDownLatch 机制，因为 CountDownLatch 有点类似于计数器，特别适合这种场景。

具体实现

---

IAnchorTask

首先，我们定义一个 IAnchorTask 接口，主要有一个方法

• isRunOnMainThread(): Boolean 表示是否在主线程运行，默认值是 false

• priority(): Int 方法 表示线程的优先级别，默认值是 Process.THREAD_PRIORITY_FOREGROUND

• needWait() 表示当我们调用 AnchorTaskDispatcher await 时，是否需要等待，return true，表示需要等待改任务执行结束，AnchorTaskDispatcher await 方法才能继续往下执行。

• fun getDependsTaskList(): List<class&gt;?</class 方法返回前置任务依赖，默认值是返回 null.

• fun run() 方法，表示任务执行的时候

1interface IAnchorTask : IAnchorCallBack {

2

3    /**

4     * 是否在主线程执行

5     */

6    fun isRunOnMainThread(): Boolean

7

8    /**

9     * 任务优先级别

10     */

11    @IntRange(

12        from = Process.THREAD_PRIORITY_FOREGROUND.toLong(),

13        to = Process.THREAD_PRIORITY_LOWEST.toLong()

14    )

15    fun priority(): Int

16

17    /**

18     * 调用 await 方法，是否需要等待改任务执行完成

19     * true 不需要

20     * false 需要

21     */

22    fun needWait(): Boolean

23

24    /**

25     * 当前任务的前置任务，可以用来确定顶点的入度

26     */

27    fun getDependsTaskList(): List<Class>?

28

29    /**

30     * 任务被执行的时候回调

31     */

32    fun run()

33

34}

它有一个实现类 AnchorTask，增加了 await 和 countdown 方法

• await 方法，调用它，当前任务会等待

• countdown() 方法，如果当前计数器值 > 0,会减一，否则，什么也不操作

1abstract class AnchorTask : IAnchorTask {

2

3    private val countDownLatch: CountDownLatch = CountDownLatch(getListSize())

4    private fun getListSize() = getDependsTaskList()?.size ?: 0

5

6    companion object {

7        const val TAG = “AnchorTask”

8    }

9

10    /**

11     * self call,await

12     */

13    fun await() {

14        countDownLatch.await()

15    }

16

17    /**

18     * parent call, countDown

19     */

20    fun countdown() {

21        countDownLatch.countDown()

22    }

23}

排序实现

无环图的拓扑排序，这里采用的是 BFS 算法。具体的可以见 AnchorTaskUtils#getSortResult 方法，它有三个参数

• list 存储所有的任务

• taskMap: MutableMap<class, AnchorTask&gt; = HashMap()</class存储所有的任务,key 是 Class

，value 是 AnchorTask

• taskChildMap: MutableMap<class, ArrayList<class&gt;?&gt; =<br /> HashMap()</class</class,储存当前任务的子任务， key 是当前任务的 class，value 是 AnchorTask 的 list

算法思想

1. 首先找出所有入度为 0 的队列，用 queue 变量存储

2. 当队列不为空，进行循环判断。

• 从队列 pop 出，添加到结果队列

• 遍历当前任务的子任务，通知他们的入度减一（其实是遍历 taskChildMap），如果入度为 0，添加到队列 queue 里面

• 当结果队列和 list size 不相等试，证明有环

1    @JvmStatic

2    fun getSortResult(

3        list: MutableList, taskMap: MutableMap<Class, AnchorTask>,

4        taskChildMap: MutableMap<Class, ArrayList<Class>?>

5    ): MutableList {

6        val result = ArrayList()

7        // 入度为 0 的队列

8        val queue = ArrayDeque()

9        val taskIntegerHashMap = HashMap<Class, Int>()

10

11        // 建立每个 task 的入度关系

12        list.forEach { anchorTask: AnchorTask ->

13            val clz = anchorTask.javaClass

14            if (taskIntegerHashMap.containsKey(clz)) {

15                throw AnchorTaskException(“anchorTask is repeat, anchorTask is $anchorTask,listis$list”)

16            }

17

18            val size = anchorTask.getDependsTaskList()?.size ?: 0

19            taskIntegerHashMap[clz] = size

20            taskMap[clz] = anchorTask

21            if (size == 0) {

22                queue.offer(anchorTask)

23            }

24        }

25

26        // 建立每个 task 的 children 关系

27        list.forEach { anchorTask: AnchorTask ->

28            anchorTask.getDependsTaskList()?.forEach { clz: Class ->

29                var list = taskChildMap[clz]

30                if (list == null) {

31                    list = ArrayList<Class>()

32                }

33                list.add(anchorTask.javaClass)

34                taskChildMap[clz] = list

35            }

36        }

37

38        // 使用 BFS 方法获得有向无环图的拓扑排序

39        while (!queue.isEmpty()) {

40            val anchorTask = queue.pop()

41            result.add(anchorTask)

42            val clz = anchorTask.javaClass

43            taskChildMap[clz]?.forEach { // 遍历所有依赖这个顶点的顶点，移除该顶点之后，如果入度为 0，加入到改队列当中

44                var result = taskIntegerHashMap[it] ?: 0

45                result–

46                if (result == 0) {

47                    queue.offer(taskMap[it])

48                }

49                taskIntegerHashMap[it] = result

50            }

51        }

52

53        // size 不相等，证明有环

54        if (list.size != result.size) {

55            throw AnchorTaskException(“Ring appeared，Please check.list is $list,resultis$result”)

56        }

57

58        return result

59

60    }

AnchorTaskDispatcher

AnchorTaskDispatcher 这个类很重要，有向无环图的拓扑排序和多线程的依赖唤醒，都是借助这个核心类完成的。

它主要有几个成员变量

1// 存储所有的任务

2    private val list: MutableList = ArrayList()

3

4    // 存储所有的任务,key 是 Class，value 是 AnchorTask

5    private val taskMap: MutableMap<Class, AnchorTask> = HashMap()

6

7    // 储存当前任务的子任务， key 是当前任务的 class，value 是 AnchorTask 的 list

8    private val taskChildMap: MutableMap<Class, ArrayList<Class>?> =

9        HashMap()

10

11    // 拓扑排序之后的主线程任务

12    private val mainList: MutableList = ArrayList()

13

14    // 拓扑排序之后的子线程任务

15    private val threadList: MutableList = ArrayList()

16

17    //需要等待的任务总数，用于阻塞

18    private lateinit var countDownLatch: CountDownLatch

19

20    //需要等待的任务总数，用于CountDownLatch

21    private val needWaitCount: AtomicInteger = AtomicInteger()

它有一个比较重要的方法 setNotifyChildren(anchorTask: AnchorTask) ，有一个方法参数 AnchorTask，它的作用是通知该任务的子任务，当前任务执行完毕，入度数减一。

1    /**

2     *  通知 child countdown,当前的阻塞任务书也需要 countdown

3     */

4    fun setNotifyChildren(anchorTask: AnchorTask) {

5        taskChildMap[anchorTask::class.java]?.forEach {

6            taskMap[it]?.countdown()

7        }

8        if (anchorTask.needWait()) {

9            countDownLatch.countDown()

10        }

11    }

接下来看一下 start 方法

1fun start(): AnchorTaskDispatcher {

最后

其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。

上面分享的腾讯、头条、阿里、美团、字节跳动等公司2019-2021年的高频面试题，博主还把这些技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，上面只是以图片的形式给大家展示一部分。

【Android思维脑图（技能树）】

知识不体系？这里还有整理出来的Android进阶学习的思维脑图，给大家参考一个方向。

【Android高级架构视频学习资源】

**Android部分精讲视频领取学习后更加是如虎添翼！**进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水，赶快领取吧！

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

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

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

图，给大家参考一个方向。

[外链图片转存中…(img-tVyJmc85-1715731068194)]

【Android高级架构视频学习资源】

**Android部分精讲视频领取学习后更加是如虎添翼！**进军BATJ大厂等（备战）！现在都说互联网寒冬，其实无非就是你上错了车，且穿的少（技能），要是你上对车，自身技术能力够强，公司换掉的代价大，怎么可能会被裁掉，都是淘汰末端的业务Curd而已！现如今市场上初级程序员泛滥，这套教程针对Android开发工程师1-6年的人员、正处于瓶颈期，想要年后突破自己涨薪的，进阶Android中高级、架构师对你更是如鱼得水，赶快领取吧！

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

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

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