Android面试：项目创建了几百个线程，你要怎么优化？(1)，不断提升自己创造溢价的能力-CSDN博客

本文链接：https://blog.csdn.net/2401_84152719/article/details/137447881

private val any: Any,
private val callStack: String,
private val poolName: String? = null
) : Runnable, Callable, Comparable {

override fun run() {
val threadId = Thread.currentThread().id
// 至此callStack、poolName、thread就可以全部关联上
// poolName和poolCreateStack可在外面事先创建关联

(any as Runnable).run()

// 任务已执行结束，callStack表示task添加栈，此时应为空代表线程当前无任务在运行
info.callStack = “”
}

override fun call(): Any {
// 类似run()方法
}

override fun compareTo(other: Any): Int {
// 省略代码
}
}

这里有一点要说明，有些task可能同时继承于Runnable、Callable、甚至Comparable，如果只包装成Runnable，当调用其他接口方法时会crash，所以这里要把已知的可能会继承的接口都实现。（当然如果后面发现没覆盖全，可以把新的接口继续加进来。至于用户自定义Runnable实现很多接口的情况不用担心。因为替换为PoolRunnable后都是系统代码在运行，主要看系统代码是否会调用call()、compareTo()等方法就好，上层随意调用被包装的runnable中各种自定义方法是没问题的）。

但是对于建立“线程-线程池”关系来说，这样要等到run()方法被执行时才能建立关系，感觉有点晚。这里可以更进一步，替换掉线程池中threadFactory，同样是自己包一层，在newThread()方法中即可及时拿到线程池创建的线程，这样就可以先和线程池建立关联，然后run()时再和堆栈建立关联。好了！new方式创建的线程池搞定，接下来看看Executors.xxx怎么玩，我们可不可以自己写个ProxyExecutors，使用asm把所有Executors.xxx都替换成ProxyExecutors.xxx，然后把其中new ThreadPool都换成new BaseThreadPool呢？

object ProxyExecutors {

@JvmStatic
fun newFixedThreadPool(nThreads: Int): ExecutorService {
return BaseThreadPoolExecutor(
nThreads, nThreads,
0L, TimeUnit.MILLISECONDS,
LinkedBlockingQueue()
)
}

@JvmStatic
fun newCachedThreadPool(): ExecutorService {
return BaseThreadPoolExecutor(
0, Int.MAX_VALUE,
60L, TimeUnit.SECONDS,
SynchronousQueue()
)
}

@JvmStatic
fun newScheduledThreadPool(
corePoolSize: Int,
threadFactory: ThreadFactory?
): ScheduledExecutorService {
return BaseScheduledThreadPoolExecutor(corePoolSize, threadFactory)
}
}

对于某些线程池确实没啥问题，但当你继续写下去时，会出问题，比如：

@JvmStatic
fun newSingleThreadScheduledExecutor(): ScheduledExecutorService {
return BaseDelegatedScheduledExecutorService(
ScheduledThreadPoolExecutor(1)
)
}

DelegatedScheduledExecutorService是Executors的私有内部类，没办法方便的写出BaseDelegatedScheduledExecutorService。所以继续观察下，发现所有创建线程池方法都返回的都是ExecutorService或ScheduledExecutorService，既然这么统一，并且这两个都是接口，那我们就使用动态代理吧！通过代理，就可以拿到接口的各种方法以及方法参数，然后为所欲为。以ExecutorService接口为例：

object ProxyExecutors {
@JvmStatic
fun newFixedThreadPool(nThreads: Int): ExecutorService {
return proxy(Executors.newFixedThreadPool(nThreads))
}
}

private fun proxy(executorService: ExecutorService): ExecutorService {
if (executorService is ThreadPoolExecutor) {
// 这里和BaseThreadPoolExecutor一样，设置ThreadFactory为了尽早获取线程信息和线程池建立联系，而不用等到run时
executorService.threadFactory = BaseThreadFactory(
executorService.threadFactory,
toObjectString(executorService)
)
}
val handler = ProxyExecutorService(executorService)
return Proxy.newProxyInstance(
executorService.javaClass.classLoader,
AbstractExecutorService::class.java.interfaces,
handler
) as ExecutorService
}

// 这里使用java是因为kotlin在调用java变长参数方法时有坑
public class ProxyExecutorService implements InvocationHandler {
private ExecutorService executor;
private String poolName = null;

ProxyExecutorService(ExecutorService executor) {
this.executor = executor;
poolName = TrackerUtils.toObjectString(executor);
// 初始化时获取线程池信息
String createStack = TrackerUtils.getStackString(false);
// 省略部分代码
}

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
// 因方法数众多，并且被代理的各类中方法也不一致
// 所以被调用方法中只要含有Runnable、Callable类型的参数，都替换成PoolRunnable代理
if (args != null) {
String callStack = TrackerUtils.getStackString(true);
for (int i = 0; i < args.length; i++) {
Object arg = args[i];
if ((arg instanceof Runnable || arg instanceof Callable) && !(arg instanceof PoolRunnable)) {
// execute submit 等情况
PoolRunnable any = new PoolRunnable(arg, callStack, poolName);
// 替换方法参数
args[i] = any;
} else if (arg instanceof Collection && !((Collection) arg).isEmpty()) {
// invokeAny invokeAll 等情况
Iterator iter = ((Collection) arg).iterator();
ArrayList taskList = new ArrayList<>();
boolean allOk = iter.hasNext();
while (iter.hasNext()) {
Object it = iter.next();
if (it instanceof Runnable || it instanceof Callable) {
if (it instanceof PoolRunnable) {
taskList.add((PoolRunnable) it);
} else {
taskList.add(new PoolRunnable(it, callStack, poolName));
}
} else {
allOk = false;
break;
}
}
if (allOk) {
// 替换方法参数
args[i] = taskList;
}
}
}
}

if (method.getName().equals(“shutdown”) || method.getName().equals(“shutdownNow”)) {
ThreadInfoManager.getINSTANCE().shutDownPool(poolName);
}
return method.invoke(executor, args);
}
}

在invoke方法中，我们把所有参数为Runnable或Callable的都替换成自己的PoolRunnable，后面和new创建线程池的套路一样，在PoolRunnable的run()或call()方法中进行线程与堆栈的关联。完美！但是考虑一个问题，如果有人不幸写出这样的代码，会发生什么呢？

val pool = Executors.newFixedThreadPool(3) as ThreadPoolExecutor

对了，会crash，因为我们动态代理后代理对象变成了ExecutorService，没办法向下转型成ThreadPoolExecutor，这也是动态代理的一个缺点，只能代理接口，如果一个类A除了实现接口还有很多自己的方法，动态代理对这些方法是无能为力的，代理后对象只是接口的实例，无法转成类A。这个问题可以使用cglib/javassist库解决，这里就不展开了。为了保险起见，我们可以把能用Base替换的都替换掉，只有类似newSingleThreadScheduledExecutor()这种不能用Base替换的才用动态代理：

object ProxyExecutors {

@JvmStatic
fun newFixedThreadPool(nThreads: Int): ExecutorService {
// 这里使用BaseThreadPoolExecutor主要是为了避免上层代码把ExecutorService转型成ThreadPoolExecutor的问题，如果使用proxy方法动态代理，上层这么做会crash
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数初中级Android工程师，想要提升技能，往往是自己摸索成长或者是报班学习，但对于培训机构动则近万的学费，着实压力不小。自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！

因此收集整理了一份《2024年Android移动开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。

既有适合小白学习的零基础资料，也有适合3年以上经验的小伙伴深入学习提升的进阶课程，基本涵盖了95%以上Android开发知识点，真正体系化！

由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频，并且会持续更新！

如果你觉得这些内容对你有帮助，可以扫码获取！！（备注：Android）

文末

好了，今天的分享就到这里，如果你对在面试中遇到的问题，或者刚毕业及工作几年迷茫不知道该如何准备面试并突破现状提升自己，对于自己的未来还不够了解不知道给如何规划，可以来看看同行们都是如何突破现状，怎么学习的，来吸收他们的面试以及工作经验完善自己的之后的面试计划及职业规划。

这里放上一部分我工作以来以及参与过的大大小小的面试收集总结出来的相关的几十套腾讯、头条、阿里、美团等公司21年的面试专题，其中把技术点整理成了视频和PDF（实际上比预期多花了不少精力），包含知识脉络 + 诸多细节，由于篇幅有限，这里以图片的形式给大家展示一部分免费分享给大家，主要还是希望大家在如今大环境不好的情况下面试能够顺利一点，希望可以帮助到大家~

还有 高级架构技术进阶脑图、Android开发面试专题资料，高级进阶架构资料帮助大家学习提升进阶，也节省大家在网上搜索资料的时间来学习，也可以分享给身边好友一起学习。

【Android核心高级技术PDF文档，BAT大厂面试真题解析】