【Android -- 面试】复习指南之 Java 并发

不断学习，做更好的自己！💪

Java 并发中考察频率较高的有线程、线程池、锁、线程间的等待和唤醒、线程特性和阻塞队列等。

1. 线程

线程的生命周期？
线程的状态有：

• new：新创建的线程
• Ready：准备就绪的线程，由于CPU分配的时间片的关系，此时的任务不在执行过程中。
• Running：正在执行的任务
• Block：被阻塞的任务
• Time Waiting：计时等待的任务
• Terminated：终止的任务
  
  线程中 wait 和 sleep 的区别？
  ​​​wait​​​ 方法既释放​​cpu​​​，又释放锁。
  ​​​sleep​​​ 方法只释放​​cpu​​，但是不释放锁。

线程和进程的区别？
线程是 ​​​CPU​​​ 调度的最小单位，一个进程中可以包含多个线程，在 ​​Android​​​ 中，一个进程通常是一个​​App​​​，​​App​​​ 中会有一个主线程，主线程可以用来操作界面元素，如果有耗时的操作，必须开启子线程执行，不然会出现 ​​ANR​​，除此以外，进程间的数据是独立的，线程间的数据可以共享。

2. 线程池

线程池的地位十分重要，基本上涉及到跨线程的框架都使用到了线程池，比如说 ​​OkHttp​​​、​​RxJava​​​、​​LiveData​​ 以及协程等。

与新建一个线程相比，线程池的特点？

• 节省开销： 线程池中的线程可以重复利用。
• 速度快：任务来了就能开始，省去创建线程的时间。
• 线程可控：线程数量可空和任务可控。
• 功能强大：可以定时和重复执行任务。

线程池中的几个参数是什么意思，线程池的种类有哪些？
线程池的构造函数如下：

public ThreadPoolExecutor(int corePoolSize,
                          int maximumPoolSize,
                          long keepAliveTime,
                          TimeUnit unit,
                          BlockingQueue<Runnable> workQueue) {
    this(corePoolSize, maximumPoolSize, keepAliveTime, unit, workQueue,
             Executors.defaultThreadFactory(), defaultHandler);
}

参数解释如下：

• ​​corePoolSize​​：核心线程数量，不会释放。
• ​​maximumPoolSize​​：允许使用的最大线程池数量，非核心线程数量，闲置时会释放。
• ​​keepAliveTime​​：闲置线程允许的最大闲置时间。
• ​​unit​​：闲置时间的单位。
• ​​workQueue​​：阻塞队列，不同的阻塞队列有不同的特性。

线程池分为四个类型：

• ​​CachedThreadPool​​：闲置线程超时会释放，没有闲置线程的情况下，每次都会创建新的线程。
• ​​FixedThreadPool​​：线程池只能存放指定数量的线程池，线程不会释放，可重复利用。
• ​​SingleThreadExecutor​​：单线程的线程池。
• ​​ScheduledThreadPool​​：可定时和重复执行的线程池。

线程池的工作流程？

图片来自​​​《线程池是怎样工作的》​​ 简而言之：

• 任务来了，优先考虑核心线程。
• 核心线程满了，进入阻塞队列。
• 阻塞队列满了，考虑非核心线程（图上好像少了这个过程）。
• 非核心线程满了，再触发拒绝任务。

3. 锁

死锁触发的四大条件？

• 互斥锁
• 请求与保持
• 不可剥夺
• 循环的请求与等待

synchronized 关键字的使用？synchronized 的参数放入对象和 Class 有什么区别？
​​​synchronized​​ 关键字的用法：

修饰方法
修饰代码块：需要自己提供锁对象，锁对象包括对象本身、对象的 ​​​Class​​​ 和其他对象。
放入对象和​​​Class​​的区别是：

锁住的对象不同：成员方法锁住的实例对象，静态方法锁住的是 ​​Class​​​。
访问控制不同：如果锁住的是实例，只会针对同一个对象方法进行同步访问，多线程访问同一个对象的​​​synchronized​​​ 代码块是串行的，访问不同对象是并行的。如果锁住的是类，多线程访问的不管是同一对象还是不同对象的 ​​synchronized​​ 代码块是都是串行的。

synchronized 的原理？
任何一个对象都有一个 ​​​monitor​​​ 与之相关联，​​JVM​​​ 基于进入和退出 ​​mointor​​ 对象来实现代码块同步和方法同步，两者实现细节不同：

• 代码块同步：在编译字节码的时候，代码块起始的地方插入​​monitorenter​​​ 指令，异常和代码块结束处插入 ​​monitorexit​​ 指令，线程在执行 ​​monitorenter​​ 指令的时候尝试获取 ​​monitor​​ 对象的所有权，获取不到的情况下就是阻塞
• 方法同步：​​synchronized​​​ 方法在​​method_info​​​ 结构有​​AAC_synchronized​​ 标记，线程在执行的时候获取对应的锁，从而实现同步方法。

synchronized 和 Lock 的区别？
主要区别：

• ​​synchronized​​​是 Java 中的关键字，是​​Java​​​ 的内置实现；​​Lock ​​​是​​Java​​ 中的接口。
• ​​synchronized​​​ 遇到异常会释放锁；​​Lock​​​ 需要在发生异常的时候调用成员方法​​Lock#unlock()​​ 方法。
• ​​synchronized​​​ 是不可以中断的，​​Lock​​ 可中断。
• ​​synchronized​​​ 不能去尝试获得锁，没有获得锁就会被阻塞；​​Lock​​ 可以去尝试获得锁，如果未获得可以尝试处理其他逻辑。
• ​​synchronized​​​ 多线程效率不如​​Lock​​​，不过​​Java​​​ 在 1.6 以后已经对​​synchronized​​ 进行大量的优化，所以性能上来讲，其实差不了多少。

悲观锁和乐观锁的举例？以及它们的相关实现？
悲观锁和乐观锁的概念：

• 悲观锁：悲观锁会认为，修改共享数据的时候其他线程也会修改数据，因此只在不会受到其他线程干扰的情况下执行。这样会导致其他有需要锁的线程挂起，等到持有锁的线程释放锁
• 乐观锁：每次不加锁，每次直接修改共享数据假设其他线程不会修改，如果发生冲突就直接重试，直到成功为止
  举例：
• 悲观锁：典型的悲观锁是独占锁，有​​synchronized​​​、​​ReentrantLock​​。
• 乐观锁：典型的乐观锁是​​CAS​​​，实现​​CAS​​​ 的​​atomic​​ 为代表的一系列类

CAS是什么？底层原理？
​​​CAS​​​ 全称 ​​Compare And Set​​​ ，核心的三个元素是：内存位置、预期原值和新值，执行 ​​CAS​​​ 的时候，会将内存位置的值与预期原值进行比较，如果一致，就将原值更新为新值，否则就不更新。
底层原理：是借助 ​​​CPU​​​ 底层指令 ​​cmpxchg​​ 实现原子操作。

4. 线程间通信

notify 和 notifyAll方法的区别？
​​​notify​​​ 随机唤醒一个线程，​​notifyAll​​ 唤醒所有等待的线程，让他们竞争锁。

wait/notify 和 Condition 类实现的等待通知有什么区别？
​​​synchronized​​​ 与 ​​wait/notify​​​ 结合的等待通知只有一个条件，而 ​​Condition​​ 类可以实现多个条件等待。

5. 多线程间的特性

多线程间的有序性、可见性和原子性是什么意思？

• 原子性：执行一个或者多个操作的时候，要么全部执行，要么都不执行，并且中间过程中不会被打断。​​Java​​​ 中的原子性可以通过独占锁和​​CAS​​ 去保证
• 可见性：指多线程访问同一个变量的时候，一个线程修改了变量的值，其他线程能够立刻看得到修改的值。锁和​​volatile​​ 能够保证可见性
• 有序性：程序执行的顺序按照代码先后的顺序执行。锁和​​volatile​​ 能够保证有序性

happens-before 原则有哪些？
Java 内存模型具有一些先天的有序性，它通常叫做 happens-before 原则。

如果两个操作的先后顺序不能通过 happens-before 原则推倒出来，那就不能保证它们的先后执行顺序，虚拟机就可以随意打乱执行指令。happens-before 原则有：

• 程序次序规则：单线程程序的执行结果得和看上去代码执行的结果要一致。
• 锁定规则：一个锁的 lock 操作一定发生在上一个 unlock 操作之后。
• volatile规则：对 volatile 变量的写操作一定先行于后面对这个变量的对操作。
• 传递规则：A 发生在 B 前面，B 发生在 C 前面，那么 A 一定发生在 C 前面。
• 线程启动规则：线程的start方法先行发生于线程中的每个动作。
• 线程中断规则：对线程的​​interrupt​​ 操作先行发生于中断线程的检测代码。
• 线程终结原则：线程中所有的操作都先行发生于线程的终止检测。
• 对象终止原则：一个对象的初始化先行发生于他的​​finalize()​​ 方法的执行。

前四条规则比较重要。

volatile 的原理？
可见性
如果对声明了 ​​​volatile​​​ 的变量进行写操作的时候，​​JVM​​​ 会向处理器发送一条 ​​Lock​​ 前缀的指令，将这个变量所在缓存行的数据写入到系统内存。

多处理器的环境下，其他处理器的缓存还是旧的，为了保证各个处理器一致，会通过嗅探在总线上传播的数据来检测自己的数据是否过期，如果过期，会强制重新将系统内存的数据读取到处理器缓存。

有序性
​​​Lock​​ 前缀的指令相当于一个内存栅栏，它确保指令排序的时候，不会把后面的指令拍到内存栅栏的前面，也不会把前面的指令排到内存栅栏的后面。

6. 阻塞队列

通常的阻塞队列有哪几种，特点是什么？

• ​​ArrayBlockQueue​​：基于数组实现的有界的 FIFO (先进先出)阻塞队列。
• ​​LinkedBlockQueue​​：基于链表实现的无界的 FIFO (先进先出)阻塞队列。
• ​​SynchronousQueue​​：内部没有任何缓存的阻塞队列。
• ​​PriorityBlockingQueue​​：具有优先级的无限阻塞队列。

ConcurrentHashMap 的原理
数据结构的实现跟 ​​​HashMap​​ 一样，不做介绍。

​​JDK 1.8​​​ 之前采用的是分段锁，核心类是一个 ​​Segment​​​，​​Segment​​​ 继承了 ​​ReentrantLock​​​，每个​​Segment​​ 对象管理若干个桶，多个线程访问同一个元素的时候只能去竞争获取锁。

​​JDK 1.8​​​ 采用了 ​​CAS + synchronized​​​，插入键值对的时候如果当前桶中没有 ​​Node​​​ 节点，使用 ​​CAS​​​ 方式进行更新，如果有​​Node​​​ 节点，则使用 ​​synchronized​​ 的方式进行更新。