Android最全【Android面试】关于多线程，你必须知道的那些玩意儿，2024年最新2024大厂Android社招面试题

最后

愿你有一天，真爱自己，善待自己。

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

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

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

public class Main {

public static void main(String[] args) {

// 第一种

Thread thread1 = new Thread(new MyRunnable());

thread1.start();

// 第二种

MyThread thread2 = new MyThread();

thread2.start();

}

}

一般来说推荐第一种写法，也就是重写Runnable了。不过这样的玩意儿存在他全是好事嘛？？？显然作为高手的你们肯定知道他有问题存在了。我们以一段代码为例。

public class Main {

public int i = 0;

public void increase(){

I++;

}

public static void main(String[] args) {

final Main main = new Main();

for(int i=0; i< 10; i++){

new Thread(new Runnable() {

@Override

public void run() {

for(int j=0; j<1000; j++){

main.increase();

}

}

}).start();

}

while(Thread.activeCount() > 2){

Thread.yield();

}

System.out.println(main.i);

}

}

这样的一段程序，你觉得最后跑出来的数据是什么？他会是10000嘛？

以答案作为标准，显然不是，他甚至说可能下次跑出来也不是我给你的这个数值，但是这是为什么呢？这就牵扯到我们的线程同步问题了。

线程同步

---

一般情况下，我们可以通过三种方式来实现。

• Synchronized

• Lock

• Volatile

在操作系统中，有这么一个概念，叫做临界区。其实就是同一时间只能允许存在一个任务访问的代码区间。代码模版如下：

Lock lock = new ReentrantLock();

public void lockModel(){

lock.lock();

// 用于书写共同代码，比如说卖同一辆动车的车票等等。

lock.unlock();

}

// 上述模版近似等价于下面的函数

public synchronized void lockModel(){}

其实这就是大家常说的锁机制，通过加解锁的方法，来保证数据的正确性。

但是锁的开销还是我们需要考虑的范畴，在不太必要时，我们更频繁的会使用是volatile关键词来修饰变量，来保证数据的准确性。

对上述的共享变量内存而言，如果线程A和B之间要通信，则必须先更新主内存中的共享变量，然后由另外一个线程去主内存中去读取。但是普通变量一般是不可见的。而volatile关键词就将这件事情变成了可能。

打个比方，共享变量如果使用了volatile关键词，这个时候线程B改变了共享变量副本，线程A就能够感知到，然后经历上述的通信步骤。

这个时候就保障了可见性。

但是另外两种特性，也就是有序性和原子性中，原子性是无法保障的。拿我们最开始的Main的类做例子，就只改变一个变量。

public volatile int i = 0;

他最后的数值终究不是10000，这是为什么呢？其实对代码进行反编译，你能够注意到这样的一个问题。

iconst_0 //把数值0 push到操作数栈

istore_1 // 把操作数栈写回到本地变量第2个位置

iinc 1,1 // 把本地变量表第2个位置加1

iload_1 // 把本地变量第2个位置的值push到操作数栈

istore_1 // 把操作数据栈写回本地变量第2个位置

一个++i的操作被反编译后出现的结果如上，给人的感觉是啥，你还会觉得它是原子操作吗？

Synchronized

这个章节的最后来简单介绍一下synchronized这个老大哥，他从过去的版本被优化后性能高幅度提高。

在他的内部结构依旧和我们Lock类似，但是存在了这样的三种锁。

偏向锁 ---------> 轻量锁（栈帧） ---------> 重量锁（Monitor）

（存在线程争夺） （自旋一定次数还是拿不到锁）

三种加锁对象：

1. 实例方法

2. 静态方法

3. 代码块

public class SyncDemo {

// 对同一个实例加锁

private synchronized void fun(){}

// 对同一个类加锁

private synchronized static void fun_static(){}

// 视情况而定

// 1. this：实例加锁

// 2. SyncDemo.class：类加锁

private void fun_inner(){

synchronized(this){

}

synchronized(SyncDemo.class){

}

}

}

线程池

===

让我们先来正题感受一下线程池的工作流程

五大参数

---

1. 任务队列（workQueue）

2. 核心线程数（coolPoolSize）： 即使处于空闲状态，也会被保留下来的线程

3. 最大线程数（maximumPoolSize）： 核心线程数 + 非核心线程数。控制可以创建的线程的数量。

4. 饱和策略（RejectedExecutionHandler）

5. 存活时间（keepAliveTime）： 设定非核心线程空闲下来后将被销毁的时间

任务队列

• 基于数组的有界阻塞队列（ArrayBlockingQueue）： 放入的任务有限，到达上限时会触发拒绝策略。

• 基于链表的无界阻塞队列（LinkedBlockingQuene）： 可以放入无限多的任务。

• 不缓存的队列（SynchronousQuene）： 一次只能进行一个任务的生产和消费。

• 带优先级的阻塞队列（PriorityBlockingQueue）： 可以设置任务的优先级。

• 带时延的任务队列（DelayedWorkQueue）

饱和策略

• CallerRunsPolicy

public static class CallerRunsPolicy implements RejectedExecutionHandler {

// 如果线程池还没关闭，就在调用者线程中直接执行Runnable

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

if (!e.isShutdown()) {

r.run();

}

}

}

• AbortPolicy

public static class AbortPolicy implements RejectedExecutionHandler {

// 拒绝任务，并且抛出RejectedExecutionException异常

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

throw new RejectedExecutionException("Task " + r.toString() +

" rejected from " +

e.toString());

}

}

• DiscardPolicy

public static class DiscardPolicy implements RejectedExecutionHandler {

// 拒绝任务，但是啥也不干

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

}

}

• DiscardOldestPolicy

public static class DiscardOldestPolicy implements RejectedExecutionHandler {

// 如果线程池还没有关闭，就把队列中最早的任务抛弃，把当前的线程插入

public void rejectedExecution(Runnable r, ThreadPoolExecutor e) {

if (!e.isShutdown()) {

e.getQueue().poll();

e.execute®;

}

}

}

五种线程池

---

FixedThreadPool

public static ExecutorService newFixedThreadPool(int nThreads) {

return new ThreadPoolExecutor(nThreads, nThreads,

0L, TimeUnit.MILLISECONDS,

new LinkedBlockingQueue());

}

固定线程池 ， 最大线程数和核心线程数的数量相同，也就意味着只有核心线程了，多出的任务，将会被放置到LinkedBlockingQueue中。

CachedThreadPool

public static ExecutorService newCachedThreadPool() {

return new ThreadPoolExecutor(0, Integer.MAX_VALUE,

60L, TimeUnit.SECONDS,

new SynchronousQueue());

}

没有核心线程，最大线程数为无穷，适用于频繁IO的操作，因为他们的任务量小，但是任务基数非常庞大，使用核心线程处理的话，数量创建方面就很成问题。

ScheduledThreadPool

public ScheduledThreadPoolExecutor(int corePoolSize,

ThreadFactory threadFactory) {

// 最后对应的还是 ThreadPoolExecutor

super(corePoolSize, Integer.MAX_VALUE, 0, NANOSECONDS,

new DelayedWorkQueue(), threadFactory);

}

最后

在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

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

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

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

最后

在这里我和身边一些朋友特意整理了一份快速进阶为Android高级工程师的系统且全面的学习资料。涵盖了Android初级——Android高级架构师进阶必备的一些学习技能。

附上：我们之前因为秋招收集的二十套一二线互联网公司Android面试真题（含BAT、小米、华为、美团、滴滴）和我自己整理Android复习笔记（包含Android基础知识点、Android扩展知识点、Android源码解析、设计模式汇总、Gradle知识点、常见算法题汇总。）

[外链图片转存中…(img-A5oIChYh-1715236151331)]

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

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

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