2019Android74道高级面试合集（含BAT字节跳动等等）
前言
最近半年，经常有人问我 “Android就业市场究竟怎么样，我还能不能坚持下去 ?”java
如今想一想，移动互联网的发展不知不觉已经十多年了，Mobile First 也已经变成了 AI First。换句话说，咱们已经再也不是“风口上的猪”。移动开发的光环和溢价开始慢慢消失，而且正在向 AI、区块链等新的领域转移。移动开发的新鲜血液也已经变少，最明显的是国内应届生都纷纷涌向了 AI 方向。面试
能够说，国内移动互联网的红利期已通过去了，如今是增量降低、存量厮杀，从争夺用户到争夺时长。比较明显的是手机厂商纷纷互联网化，与传统互联网企业直接竞争。另一方面，过去渠道的打法失灵，小程序、快应用等新兴渠道崛起，不管是手机厂商，仍是各大 App 都把出海摆到了战略的位置。数据库
各大培训市场也再也不培训Android，做为开发Android的咱们该何去何从？小程序
其实若是你技术深度足够，大必不用为就业而忧愁。每一个行业未尝不是这样，最开始的风口，到慢慢的成熟。Android初级在2019年的日子里风光再也不， 靠会四大组件就可以获取到满意薪资的时代一去不复返。**通过一波一波的淘汰与洗牌，剩下的都是技术的金子。就像大浪褪去，裸泳的会慢慢上岸。**而真正坚持下来的必定会取得不错成绩。毕竟Android市场是如此之大。从Android高级的蓬勃的就业岗位需求来看，能坚信咱们每一位Android开发者的梦想 。后端
接下来咱们针对Android高级展开的完整面试题 2019Android74道高级面试题合集目录（含BAT 字节跳动等等）缓存
阿里巴巴 谈谈你对Android线程池原理的理解
专一分享大型Bat面试知识，后续会持续更新，喜欢的话麻烦点击关注一下bash
1.简介
线程池能够简单看作是一组线程的集合，经过使用线程池，咱们能够方便的复用线程，避免了频繁建立和销毁线程所带来的开销。在应用上，线程池可应用在后端相关服务中。好比 Web 服务器，数据库服务器等。以 Web 服务器为例，假如 Web 服务器会收到大量短时的 HTTP 请求，若是此时咱们简单的为每一个 HTTP 请求建立一个处理线程，那么服务器的资源将会很快被耗尽。固然咱们也能够本身去管理并复用已建立的线程，以限制资源的消耗量，但这样会使用程序的逻辑变复杂。好在，幸运的是，咱们没必要那样作。在 JDK 1.5 中，官方已经提供了强大的线程池工具类。经过使用这些工具类，咱们能够用低廉的代价使用多线程技术。服务器
线程池做为 Java 并发重要的工具类，在会用的基础上，我以为颇有必要去学习一下线程池的相关原理。毕竟线程池除了要管理线程，还要管理任务，同时还要具有统计功能。因此多了解一点，仍是能够扩充眼界的，同时也能够更为熟悉线程池技术。多线程
2.继承体系
线程池所涉及到的接口和类并非不少，其继承体系也相对简单。相关继承关系以下： 并发
如上图，最顶层的接口 Executor 仅声明了一个方法execute。ExecutorService 接口在其父类接口基础上，声明了包含但不限于shutdown、submit、invokeAll、invokeAny 等方法。至于 ScheduledExecutorService 接口，则是声明了一些和定时任务相关的方法，好比 schedule和scheduleAtFixedRate。线程池的核心实现是在 ThreadPoolExecutor 类中，咱们使用 Executors 调用newFixedThreadPool、newSingleThreadExecutor和newCachedThreadPool等方法建立线程池均是 ThreadPoolExecutor 类型。
以上是对线程池继承体系的简单介绍，这里先让你们对线程池大体轮廓有必定的了解。接下来我会介绍一下线程池的实现原理，继续往下看吧。
3.原理分析
3.1 核心参数分析
3.1.1 核心参数简介
如上节所说，线程池的核心实现即 ThreadPoolExecutor 类。该类包含了几个核心属性，这些属性在可在构造方法进行初始化。在介绍核心属性前，咱们先来看看 ThreadPoolExecutor 的构造方法，以下：
public ThreadPoolExecutor(int corePoolSize,
int maximumPoolSize,
long keepAliveTime,
TimeUnit unit,
BlockingQueue<Runnable> workQueue,
ThreadFactory threadFactory,
RejectedExecutionHandler handler)
复制代码
如上所示，构造方法的参数即核心参数，这里我用一个表格来简要说明一下各个参数的意义。以下：
以上是各个参数的简介，下面我将会针对部分参数进行详细说明，继续往下看。
3.1.2 线程建立规则
在 Java 线程池实现中，线程池所能建立的线程数量受限于 corePoolSize 和 maximumPoolSize 两个参数值。线程的建立时机则和 corePoolSize 以及 workQueue 两个参数有关。下面列举一下线程建立的4个规则（线程池中无空闲线程），以下：
- 线程数量小于 corePoolSize，直接建立新线程处理新的任务
- 线程数量大于等于 corePoolSize，workQueue 未满，则缓存新任务
- 线程数量大于等于 corePoolSize，但小于 maximumPoolSize，且 workQueue 已满。则建立新线程处理新任务
- 线程数量大于等于 maximumPoolSize，且 workQueue 已满，则使用拒绝策略处理新任务
简化一下上面的规则：
3.1.3 资源回收
考虑到系统资源是有限的，对于线程池超出 corePoolSize 数量的空闲线程应进行回收操做。进行此操做存在一个问题，即回收时机。目前的实现方式是当线程空闲时间超过 keepAliveTime 后，进行回收。除了核心线程数以外的线程能够进行回收，核心线程内的空闲线程也能够进行回收。回收的前提是allowCoreThreadTimeOut属性被设置为 true，经过public void allowCoreThreadTimeOut(boolean)方法能够设置属性值。
3.1.4 排队策略
如3.1.2 线程建立规则一节中规则2所说，当线程数量大于等于 corePoolSize，workQueue 未满时，则缓存新任务。这里要考虑使用什么类型的容器缓存新任务，经过 JDK 文档介绍，咱们可知道有3中类型的容器可供使用，分别是同步队列，有界队列和无界队列。对于有优先级的任务，这里还能够增长优先级队列。以上所介绍的4中类型的队列，对应的实现类以下：
3.1.5 拒绝策略
如3.1.2 线程建立规则一节中规则4所说，线程数量大于等于 maximumPoolSize，且 workQueue 已满，则使用拒绝策略处理新任务。Java 线程池提供了4中拒绝策略实现类，以下：
public void setRejectedExecutionHandler(RejectedExecutionHandler)修改线程池决绝策略。
3.2 重要操做
3.2.1 线程的建立与复用
在线程池的实现上，线程的建立是经过线程工厂接口ThreadFactory的实现类来完成的。默认状况下，线程池使用Executors.defaultThreadFactory()方法返回的线程工厂实现类。固然，咱们也能够经过
public void setThreadFactory(ThreadFactory)方法进行动态修改。具体细节这里就很少说了，并不复杂，你们能够本身去看下源码。
在线程池中，线程的复用是线程池的关键所在。这就要求线程在执行完一个任务后，不能当即退出。对应到具体实现上，工做线程在执行完一个任务后，会再次到任务队列获取新的任务。若是任务队列中没有任务，且 keepAliveTime 也未被设置，工做线程则会被一致阻塞下去。经过这种方式便可实现线程复用。
说完原理，再来看看线程的建立和复用的相关代码（基于 JDK 1.8），以下：
+----ThreadPoolExecutor.Worker.java
Worker(Runnable firstTask) {
setState(-1);
this.firstTask = firstTask;
// 调用线程工厂建立线程
this.thread = getThreadFactory().newThread(this);
}
// Worker 实现了 Runnable 接口
public void run() {
runWorker(this);
}
+----ThreadPoolExecutor.java
final void runWorker(Worker w) {
Thread wt = Thread.currentThread();
Runnable task = w.firstTask;
w.firstTask = null;
w.unlock();
boolean completedAbruptly = true;
try {
// 循环从任务队列中获取新任务
while (task != null || (task = getTask()) != null) {
w.lock();
// If pool is stopping, ensure thread is interrupted;
// if not, ensure thread is not interrupted. This
// requires a recheck in second case to deal with
// shutdownNow race while clearing interrupt
if ((runStateAtLeast(ctl.get(), STOP) ||
(Thread.interrupted() &&
runStateAtLeast(ctl.get(), STOP))) &&
!wt.isInterrupted())
wt.interrupt();
try {
beforeExecute(wt, task);
Throwable thrown = null;
try {
// 执行新任务
task.run();
} catch (RuntimeException x) {
thrown = x; throw x;
} catch (Error x) {
thrown = x; throw x;
} catch (Throwable x) {
thrown = x; throw new Error(x);
} finally {
afterExecute(task, thrown);
}
} finally {
task = null;
w.completedTasks++;
w.unlock();
}
}
completedAbruptly = false;
} finally {
// 线程退出后，进行后续处理
processWorkerExit(w, completedAbruptly);
}
}
复制代码
3.2.2 提交任务
一般状况下，咱们能够经过线程池的submit方法提交任务。被提交的任务可能会当即执行，也可能会被缓存或者被拒绝。任务的处理流程以下图所示：
+---- AbstractExecutorService.java
public Future<?> submit(Runnable task) {
if (task == null) throw new NullPointerException();
// 建立任务
RunnableFuture<Void> ftask = newTaskFor(task, null);
// 提交任务
execute(ftask);
return ftask;
}
+---- ThreadPoolExecutor.java
public void execute(Runnable command) {
if (command == null)
throw new NullPointerException();
int c = ctl.get();
// 若是工做线程数量 < 核心线程数，则建立新线程
if (workerCountOf(c) < corePoolSize) {
// 添加工做者对象
if (addWorker(command, true))
return;
c = ctl.get();
}
// 缓存任务，若是队列已满，则 offer 方法返回 false。不然，offer 返回 true
if (isRunning(c) && workQueue.offer(command)) {
int recheck = ctl.get();
if (! isRunning(recheck) && remove(command))
reject(command);
else if (workerCountOf(recheck) == 0)
addWorker(null, false);
}
// 添加工做者对象，并在 addWorker 方法中检测线程数是否小于最大线程数
else if (!addWorker(command, false))
// 线程数 >= 最大线程数，使用拒绝策略处理任务
reject(command);
}
private boolean addWorker(Runnable firstTask, boolean core) {
retry:
for (;;) {
int c = ctl.get();
int rs = runStateOf(c);
// Check if queue empty only if necessary.
if (rs >= SHUTDOWN &&
! (rs == SHUTDOWN &&
firstTask == null &&
! workQueue.isEmpty()))
return false;
for (;;) {
int wc = workerCountOf(c);
// 检测工做线程数与核心线程数或最大线程数的关系
if (wc >= CAPACITY ||
wc >= (core ? corePoolSize : maximumPoolSize))
return false;
if (compareAndIncrementWorkerCount(c))
break retry;
c = ctl.get(); // Re-read ctl
if (runStateOf(c) != rs)
continue retry;
// else CAS failed due to workerCount change; retry inner loop
}
}
boolean workerStarted = false;
boolean workerAdded = false;
Worker w = null;
try {
// 建立工做者对象，细节参考上一节所贴代码
w = new Worker(firstTask);
final Thread t = w.thread;
if (t != null) {
final ReentrantLock mainLock = this.mainLock;
mainLock.lock();
try {
int rs = runStateOf(ctl.get());
if (rs < SHUTDOWN ||
(rs == SHUTDOWN && firstTask == null)) {
if (t.isAlive()) // precheck that t is startable
throw new IllegalThreadStateException();
// 将 worker 对象添加到 workers 集合中
workers.add(w);
int s = workers.size();
// 更新 largestPoolSize 属性
if (s > largestPoolSize)
largestPoolSize = s;
workerAdded = true;
}
} finally {
mainLock.unlock();
}
if (workerAdded) {
// 开始执行任务
t.start();
workerStarted = true;
}
}
} finally {
if (! workerStarted)
addWorkerFailed(w);
}
return workerStarted;
}
复制代码
上面的代码略多，不过结合上面的流程图，和我所写的注释，理解主逻辑应该不难。
3.2.3 关闭线程池
咱们能够经过shutdown和shutdownNow两个方法关闭线程池。两个方法的区别在于，shutdown 会将线程池的状态设置为SHUTDOWN，同时该方法还会中断空闲线程。shutdownNow 则会将线程池状态设置为STOP，并尝试中断全部的线程。中断线程使用的是Thread.interrupt方法，未响应中断方法的任务是没法被中断的。最后，shutdownNow 方法会将未执行的任务所有返回。
调用 shutdown 和 shutdownNow 方法关闭线程池后，就不能再向线程池提交新任务了。对于处于关闭状态的线程池，会使用拒绝策略处理新提交的任务。
4.几种线程池
通常状况下，咱们并不直接使用 ThreadPoolExecutor 类建立线程池，而是经过 Executors 工具类去构建线程池。经过 Executors 工具类，咱们能够构造5中不一样的线程池。下面经过一个表格简单介绍一下几种线程池，以下：
下一篇逐步讲解2019Android高级面试题阿里篇第二道面试题：垃圾回收机制的实现
- 1. AndroidBAT. 字节跳动74道高级面试第二篇
- 2. 字节跳动面经合集（一）
- 3. 字节跳动面经 合集
- 4. 字节跳动上千道精选面试题还不刷起来！2019-2020大厂高级面试题集合（Handler，性能优化，自定义View等）
- 5. 字节跳动面试题
- 6. 8.11字节跳动面试
- 7. 2019 BAT等大厂Android高级面试题汇总
- 8. 【大厂面试】字节跳动、京东等大厂面试题分享，已拿字节offer~
- 9. 已拿Offer！百度、字节跳动等后台面经
- 10. 面试 -- 字节跳动(视频面)
- 更多相关文章...
- • XML DOM 高级 - XML 教程
- • Rust 集合与字符串 - RUST 教程
- • 为了进字节跳动，我精选了29道Java经典算法题，带详细讲解
- • ☆技术问答集锦（13）Java Instrument原理
-
每一个你不满意的现在，都有一个你没有努力的曾经。