审核解析结果

返回队列

任务 ID: job_df38be00ebd443cea7f14360931d189f
任务类型: 提取面经
状态: 已确认
尝试次数: 8

来源上下文

知识笔记来源已确认任务已确认

Java八股（并发）.md

src_d56c6f68bef64843bc0edc9ff0035e78

创建于 2026/03/28 17:54，最近更新时间 2026/04/07 12:16

公司岗位轮次标签

摘要原文

# Java并发
## 基础概念
### 什么是线程和进程？
进程是程序的一次执行过程，是系统运行程序的基本单位，程序的执行对应着一个进程的创建、运行和销毁。在Java中，启动main函数就是启动了一个JVM进程，而main函数所在线程称为主线程。

而线程是一个比进程更小的执行单位，一个进程下可以有多个线程，多个线程之间共享进程的一些资源，如堆、方法区，同时各个线程也有一些自己的私有资源，如程序计数器、虚拟机栈、本地方法栈等。且在线程之间切换的开销要比进程小得多。

### <font style="color:rgb(44, 62, 80);">请简要描述线程与进程的关系,区别及优缺点？</font>
线程是一个比进程更小的执行单位，一个进程下可以有多个线程，多个线程之间共享进程的一些资源，如堆、方法区，同时各个线程也有一些自己的私有资源，如程序计数器、虚拟机栈、本地方法栈等。相比进程，各个进程之间相互独立，而线程则不一定。线程执行开销小，但不利于资源的管理和保护，而进程则相反。

### <font style="color:rgb(44, 62, 80);">程序计数器为什么是私有的?</font>
首先明白程序计数器的作用：程序计数器是用来记录解释器读取的指令位置，实现流程控制，如顺序，选择，循环；

而在多线程情况下，可能会发生线程的切换，CPU从当前线程切换到另一个线程进行执行，而当再切回原来的线程时，必须知道从哪里开始继续执行，因此要用到程序计数器。而如果程序计数器不是私有的，有可能在执行其他线程时，程序计数器被修改了，导致结果错误。

### <font style="color:rgb(44, 62, 80);">虚拟机栈和本地方法栈为什么是私有的?</font>
虚拟机栈：一个方法的执行对应于虚拟机栈中一个栈帧的入栈和出栈的过程，而栈帧中存储着操作数栈、局部变量表、常量池引用等相关信息，如果这些信息被其他线程修改，就会造成执行结果错误。

本地方法栈和虚拟机栈类似，只不过它存储的是本地方法。

### <font style="color:rgb(44, 62, 80);">并发与并行的区别</font>
并发就是多个线程在同一时间段内执行。

并行就是多个线程在同一时刻执行。

### <font style="color:rgb(44, 62, 80);">同步和异步的区别</font>
同步就是调用方法后，需要等待结果再返回。

异步就是调用方法后，不用等待结果，直接返回。

### <font style="color:rgb(44, 62, 80);">为什么要使用多线程?</font>
因为相比于进程之间的切换，线程间的切换开销更小。同时，现在的CPU基本都是多核的，也就是多个线程可以同时运行，这也进一步减小了线程上下文切换的开销。

此外，如今的业务场景下，许多都是高并发场景，因此多线程并发编程能够大幅提高系统整体的并发能力和性能。

### Java是怎么解决并发问题的？
Java提出了内存模型JMM，定义了一些从java源代码到可执行的机器指令这个转化过程中必须遵守的原则，比如happens-before，并且提供了像synchronized，volatile，final这些关键字，来解决并发问题。对于并发的几个问题，比如原子性，Java保证了一些基本操作的原子性，比如读取和赋值，对于更大范围的原子性可以使用synchronized或lock锁来实现。还有就是可见性，java使用volatile关键字来保证可见性。有序性的话，java使用volatile，插入内存屏障来禁止指令重排序，保证有序性。还有happens-before原则也用来保证有序性。

### 什么是守护线程？
守护线程就是为其他线程服务的特殊线程，在后台完成一些系统性任务，比如垃圾回收线程，当程序运行完成时，jvm会杀死守护线程。可以使用setDaemon方法来设置守护线程。

### 线程安全有哪些实现思路？
互斥同步：synchronized和lock锁

非阻塞同步：CAS、原子类

无同步方案：栈封闭、threadlocal

### 那线程同步呢？
互斥同步、非阻塞同步

### <font style="color:rgb(44, 62, 80);">使用多线程可能带来什么问题?</font>
死锁、内存泄漏、线程不安全

### <font style="color:rgb(44, 62, 80);">说说线程的生命周期和状态?</font>
线程一共有6个状态

初始状态：new一个线程时，处于初始状态

RUNNABLE：运行状态，调用start方法进入runnable状态

WAITING：等待状态，需要其它方法进行唤醒（wait）

BLOCKED：阻塞状态，需要等待锁释放

TIME_WAITING：超时等待状态，当等待时间超过指定时间后直接返回（sleep）

TERMINATED：终止状态，线程运行完毕

线程的生命周期就是从初始状态开始，某一时刻处于某一状态，直到线程结束。

### <font style="color:rgb(44, 62, 80);">为什么 JVM 没有区分（READY/RUNNING）这两种状态呢？</font>
由于操作系统的CPU调度通常是采用时间片方式进行抢占式轮转调度，而这个时间片非常小，当一个线程分配到时间片时，就从ready进入running，而经过时间片，马上进入ready，两者频繁切换，因此区分两种状态没什么意义。

### <font style="color:rgb(44, 62, 80);">什么是上下文切换?</font>
上下文是指线程在执行过程中自己的运行条件和状态，上下文切换就是线程退出CPU，可能有以下几种情况导致：

主动：主动让出CPU，如调用sleep，wait方法；发出阻塞类型的系统中断，如请求IO，线程被阻塞；

被动：时间片结束；

频繁的切换意味着频繁的保存和恢复线程信息，会导致性能降低。

### <font style="color:rgb(44, 62, 80);">什么是线程死锁?</font>
死锁是指多个线程同时阻塞，并且等待彼此的资源释放而导致的无限期阻塞。

产生死锁有四个条件：

、
互斥条件：一个资源在任一时刻只能由一个线程占用

请求与保持条件：一个线程在持有资源并进一步申请其他资源时，不释放持有的资源

不剥夺条件：线程占有的资源只会由自己释放而不会被其他线程强行剥夺

循环与等待条件：多个线程形成首尾相连的循环等待关系

### <font style="color:rgb(44, 62, 80);">如何预防和避免线程死锁?</font>
预防死锁可以通过破坏死锁的必要条件：

破坏请求与保持条件：一次性申请所有的资源

破坏不剥夺条件：在线程进一步申请其他资源时，如果申请不到，则释放已占用的锁

破坏循环等待条件：按序申请资源，并按反序释放资源

避免死锁可以使用银行家算法进行资源分配。

### 什么是银行家算法？
### <font style="color:rgb(44, 62, 80);">sleep() 方法和 wait() 方法对比</font>
wait释放锁，sleep不释放锁

sleep主要用于让线程暂停运行，而wait通常用于线程间的交互

sleep在执行完之后会自动唤醒线程，wait则需要其他线程调用notify或notifyAll方法来唤醒

sleep是Thread的静态本地方法，而wait是Object类的方法

### <font style="color:rgb(44, 62, 80);">为什么 wait() 方法不定义在 Thread 中？</font>
wait方法是让获得对象锁的线程等待，并释放当前对象的锁，操作的是对象，而sleep方法则操作的是线程。

### <font style="color:rgb(44, 62, 80);">Thread.sleep()、Object.wait()、Condition.await()、LockSupport.park()的区别? </font>
首先sleep和wait：

1. sleep不会释放锁，而wait会释放锁；
2. sleep必须传入时间参数，wait可传可不传
3. sleep等待一段时间后自动唤醒，继续执行，wait必须等待其他线程调用notify或notifyall方法，且唤醒后不一定继续执行，需要重新获得锁，如果设置了等待时间则会自动唤醒。

然后是wait和await方法：

wait和await方法大致相同，不过await方法底层是使用LockSupport.park方法进行阻塞的。且在阻塞之前会把当前线程添加到条件队列，并让state变为0；

最后是sleep和park：

sleep和park的功能类似，都是阻塞线程，且不会释放锁，但是park可以被另一个线程调用unpark来唤醒，而sleep需要自动唤醒。sleep会抛出interruptedExceptiron，需要进行捕获或抛出，而park不用。

### <font style="color:rgb(44, 62, 80);">可以直接调用 Thread 类的 run 方法吗？</font>
不可以。当我们new一个线程并执行start方法，此时线程会进入runnable状态，当获得时间片时，start方法会进行相应的准备，并自动执行run方法，而如果直接执行run方法，会把run方法当成main线程下的一个普通线程来进行执行。

### <font style="color:rgb(44, 62, 80);">Runnable vs Callable 有什么区别</font>
Callable是jdk1.5引入来处理runnable不支持的用例。runnable接口是没有返回值，也不会抛出检查异常的，而callable则可以。且new Thread时只能传入runnable接口的实现类，不能传入callable的实现类，因此可以将callable传入future等类进行封装，在传入Thread中。

## JMM&Volatile
### 什么是volatile？
在java中，volatile关键字可以用来保证变量的可见性，用volatile修饰一个变量，代表该变量是共享且不稳定的，每次使用它的时候需要到主存中进行读取。它能够保证数据的可见性，但不能保证数据的原子性。而synchronized两者都能保证。

### volatile有哪些应用？
volatile主要可以用来保证有序性，因此像比如双重检验锁，这种需要强调可见性的地方可以使用volatile。

### 什么是指令重排序?
指令重排序就是指计算机执行指令的顺序和代码编写的顺序不一定是相同的，因为计算机为了提高运行效率，可能会对指令进行重排序。

指令重排序主要有两种，一种是编译器优化重排，编译器会在保证串行语义一致的前提下，对代码进行优化重排。第二种是处理器重排，像现代的CPU都采用了指令级并行技术，将多条指令重叠执行，当不存在数据依赖性时，就会对机器指令进行重排序。

指令重排序能够保证串行语义的一致，但没有义务保证多线程之间的一致性，因此在多线程下可能会产生一些问题。我们可以通过一些方法来避免这种情况，对于编译器而言，我们可以通过相应的指令禁止特定类型的重排序，对于处理器而言，我们可以通过插入内存屏障来禁止特定类型的重排序。

### 什么是内存屏障?
内存屏障是一种CPU指令，用来禁止处理器指令的重排序，通过插入内存屏障，可以保证指令执行的有序性。内存屏障主要分为写屏障和读屏障，写屏障保证写屏障之前的所有操作不会被重排到屏障后面，读屏障保证屏障之后的所有操作不会被重排到屏障之前。

### <font style="color:rgb(44, 62, 80);">什么是 JMM？为什么需要 JMM？</font>
JMM时java的内存模型，它是java定义的一套多线程并发编程的规范，它抽象了线程和主存的关系，并且规定了从java源代码到cpu可执行指令的转化过程中，需要遵守哪些规范和原则。它的主要目的就是简化多线程并发编程，增强程序的可移植性。

<font style="color:rgb(18, 18, 18);">Java虚拟机规范中定义了Java内存模型（Java Memory Model，JMM），用于屏蔽掉各种硬件和操作系统的内存访问差异，以实现让Java程序在各种平台下都能达到一致的并发效果，JMM规范了Java虚拟机与计算机内存是如何协同工作的：规定了一个线程如何和何时可以看到由其他线程修改过后的共享变量的值，以及在必须时如何同步的访问共享变量。</font>

<font style="color:rgb(18, 18, 18);">Java内存模型规定</font>**<font style="color:rgb(18, 18, 18);">所有的变量都存储在主内存</font>**<font style="color:rgb(18, 18, 18);">中，包括实例变量，静态变量，但是不包括局部变量和方法参数。每个线程都有自己的工作内存，</font>**<font style="color:rgb(18, 18, 18);">线程的工作内存保存了该线程用到的变量和主内存的副本拷贝，线程对变量的操作都在工作内存中进行</font>**<font style="color:rgb(18, 18, 18);">。</font>**<font style="color:rgb(18, 18, 18);">线程不能直接读写主内存中的变量</font>**<font style="color:rgb(18, 18, 18);">。</font>

### <font style="color:rgb(44, 62, 80);">为什么要遵守这些并发相关的原则和规范呢？</font>
因为在并发编程下，程序可能会出现各种问题，因此需要定义一些规范，用以解决这些问题。像比如指令重排序问题，JMM就抽象了happens-before原则，来解决这个问题。这样能够简化并发编程， 程序员只需要使用java提供的一些类，关键字等，就能够实现并发编程，而不用关心底层原理。

### <font style="color:rgb(44, 62, 80);">JMM 是如何抽象线程和主内存之间的关系？</font>
JMM抽象了线程和主内存之间的关系，它定义了共享变量必须存储在主内存当中，在jdk1.2之前，java内存模型的实现就是总是从主存当中读取共享变量的值，但现在的内存模型，线程可以拷贝一份共享变量的副本到本地内存，而不直接在主内存进行读写。

### <font style="color:rgb(44, 62, 80);">什么是主内存？什么是本地内存？</font>
主内存就是所有线程创建的实例对象都放在主内存当中，不论是实例变量还是局部变量。

本地内存就是线程私有的一个本地内存，来存储共享变量的副本。每个线程只能访问自己的本地内存，而不能访问其他线程的。

### <font style="color:rgb(44, 62, 80);">Java 内存区域和 JMM 有何区别？</font>
Java内存区域是和JVM的运行时区域相关，它定义了jvm在运行时是如何分区存储程序数据的，像比如堆中主要就放对象实例。

而JMM内存模型是和Java的并发编程相关的，它抽象了线程和主存之间的关系，比如所有的共享变量都需要存储在主内存当中，它规定了从java源代码到CPU可执行指令这个转化过程中需要遵循的规范和原则，主要目的是简化并发编程，提高程序的可移植性。

### <font style="color:rgb(44, 62, 80);">happens-before 原则是什么？</font>
happens-before原则主要就是描述了两个操作之间的内存可见性。它主要是为了实现程序员和编译器、处理器之间的平衡。因为程序员追求的是易理解的强内存模型，只需要遵循既定的规则去进行编程就可以了，而编译器和处理器追求的是约束更少的弱内存模型，他们的目的是优化性能，最大化性能。因此，happens-before原则的思想就是，尽量减少编译器和处理器的约束，对于不会影响程序结果的重排序，就允许编译器和处理器为了提升性能而去进行重排序，而对于会影响结果的重排序，JMM就要禁止。

happens-before原则定义了如果一个操作happens-before于另一个操作，那么第一个操作的结果是对第二个操作可见的。并且第一个操作的执行顺序要在第二个操作之前。

### <font style="color:rgb(44, 62, 80);">happens-before 常见规则有哪些？谈谈你的理解？</font>
+ 程序顺序规则：一个线程内，按照代码顺序，前面的操作happens-before后面的操作
+ 解锁规则：解锁操作必须happens-before加锁操作
+ volatile变量规则：对于一个volatile变量的写操作必须happens-before后面对这个变量的读操作
+ 传递规则：A happens-before B， B happens-before C， 则A happens-before C
+ 线程启动规则：线程的start方法happens-before该线程的每一个动作

### 什么是原子性？什么是可见性？什么是有序性？
+ 原子性就是一个或多个操作要么所有操作都执行，且不会受其他因素的干扰或中断，要么都不执行。在Java当中我们可以使用synchronized、各种Lock锁和原子类来保证原子性。synchronized和lock是通过加锁保证任一时刻只有一个线程能够访问资源，从而保证有序性，而原子类是通过CAS操作来保证有序性。
+ 可见性就是一个线程对于共享变量的修改，其他线程是可以立即看到修改后的值的。在java中我们可以通过使用synchronized、各种lock锁和volatile来实现可见性。用volatile修饰一个变量，就指示jvm这个变量是共享且不稳定的，在每次使用该变量时，到主内存当中去读取，从而保证可见性。
+ 有序性就是由于指令重排序问题的存在，代码的执行顺序不一定就是编写的顺序，我们可以通过volatile关键字，插入内存屏障来禁止指令重排序，保证有序性。

### <font style="color:rgb(44, 62, 80);">如何禁止指令重排序？</font>
禁止指令重排序可以使用volatile来修饰变量，volatile可以禁止jvm进行指令重排序，在对这个变量进行读写操作的时候，会加入相应的内存屏障来防止指令重排序。

举个例子？->单例模式双重检验锁

### volatile如何保证可见性？
当我们对volatile修饰的变量进行写操作的时候，JVM就会像系统发送一条lock前缀的命令，将这个变量的值写回到系统内存当中，而为了保证各个处理器缓存一致，实现了缓存一致性协议，各个处理器通过嗅探总线上传播的数据来检查自己的缓存是否过期，如果过期，则会将自己的数据设置为无效状态，当该CPU上的线程对这个数据进行读取时的时候，会重新从主内存当中读取数据，从而保证了数据的可见性。同时使用内存屏障来保证并发状态下的数据一致性。

### 内存屏障怎么保证并发状态下的数据一致性？

### <font style="color:rgb(44, 62, 80);">volatile 可以保证原子性么？</font>
不可以。volatile只能保证变量的可见性，因为它要求在每次对变量进行读写操作的时候，都到主存当中去读取。但是它并不会使得一些操作是原子性的。要保证操作的原子性，可以用synchronized、lock或则atomic类来实现。

### <font style="color:rgb(44, 62, 80);">乐观锁和悲观锁</font>
悲观锁就是从悲观的角度出发，认为线程对共享资源的每一次操作都会被其他线程影响，所以每一次操作都要进行加锁，并且其他线程需要阻塞等到上一个持有锁的线程释放了之后才能去抢夺锁。悲观锁适用于多写的场景，能够避免频繁的失败导致CPU空转。

而乐观锁就是从乐观的角度出发，认为线程对共享资源的每一次操作都是安全的，不会被影响，所以不需要加锁，只需要进行一定的校验即可，常用的有版本号机制和CAS。乐观锁通常用于多读的场景，避免频繁加锁降低性能，提高了系统的吞吐量。

### <font style="color:rgb(44, 62, 80);">如何实现乐观锁？（什么是版本号机制？什么是CAS？）</font>
乐观锁的实现通常使用版本号机制或者CAS，CAS相对较多。

所谓版本号机制，就是线程在对共享资源进行操作的时候，不需要加锁，只需要给共享资源加上一个版本号，在线程读取资源的时候记录下版本号，然后再写入的时候比较当前版本号和记录的版本号是否一致，一致则写入，并且版本号加一，不一致则重试。

CAS的思想和版本号机制类似，就是用一个预期值和当前值比较，一致则更新，否则重试。具体来说，CAS是一个原子操作，依赖于一条CPU原子指令，其涉及当前值、预期值和写入的新值。当线程读取资源时，记录下当前资源的值为预期值，并进行操作，在更新时，判断当前值和之前记录的预期值是否一致，一致则更新为新值，否则说明其他线程修改了该资源，重试。

sun.misc.Unsafe提供了compareAndSwapObject、<font style="color:rgb(44, 62, 80);">compareAndSwapInt</font><font style="color:rgb(44, 62, 80);">、</font><font style="color:rgb(44, 62, 80);">compareAndSwapLong来实现对object、int、long的CAS操作。</font>

### <font style="color:rgb(44, 62, 80);">什么是原子操作？</font>
原子操作即最小的不可拆分的操作，原子操作一旦开始执行，则不能被打断，知道执行结束。

### <font style="color:rgb(44, 62, 80);">乐观锁（CAS）存在哪些问题？</font>
ABA、CPU空转、只能保证一个变量的原子操作

+ ABA问题：ABA问题就是说，当多个线程去操作一个资源时，比如线程1读取资源，记录预期值为A，然后此时线程2读取资源，并将资源修改为B，之后可能又将其修改为A，此时线程1继续执行，虽然当前值和预期值匹配，但此时的A并不是一开始的A，而是可能被修改过了。这就是ABA问题。ABA问题的解决方法就是可以加上一个时间戳，在JDK1.5之后，时使用AtomicStampedReference来解决的。他就是在检查的时候同时检查时间戳是否相等，相等则以原子方式进行更新。
+ CPU空转就是CAS通常会使用自旋锁的方式来实现，当获取不成功时就循环进行获取直到成功，如果长时间不成功的话就会使CPU空转，增大开销。（解决方法：限制循环次数？合理使用自旋锁？）
+ 对于CAS而言，它只对单个变量有效，不能操作跨多个变量。在JDK1.5之后，可以使用AtomicReference类来保证引用对象之间的原子性，将多个变量封装到一个对象里进行操作。

## <font style="color:rgb(44, 62, 80);">synchronized 关键字</font>
### <font style="color:rgb(44, 62, 80);">synchronized 是什么？有什么用？</font>
synchronized使Java中的一个关键字，它能够解决多线程之间访问资源的同步性，保证它修饰的方法或代码块任一时刻只能有一个线程访问。

在Java的早期版本，synchronized是一个重量级锁，效率低下，因为它使用monitor，依赖于底层操作系统的MutexLock来实现，Java的线程使映射到操作系统的原生线程上的，如果挂起或唤醒一个线程，都需要操作系统来帮忙，需要频繁的切换用户态和内核态，效率较低。

而jdk1.6之后，synchronized引入了偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁粗化、锁消除等操作，减小了锁的开销。

### 什么是偏向锁？
偏向锁就是当只有一个线程访问这个共享资源的时候，如果按原来的频繁对他进行加锁，就会耗费过多的资源，因此引入了偏向锁，当只有一个线程访问这个共享资源的时候，就会将共享资源的对象头中的MarkWord记录为指向自己的线程ID，然后再下一次进来的时候就会判断当前记录的id是否指向自己，如果是就直接开始执行，不需要加锁操作，降低了资源消耗。

### 什么是轻量级锁？
轻量级锁就是当任一时刻只有两个线程在竞争资源，当线程A占有资源时，线程B竞争，并使用CAS尝试修改MarkWord为只想自己lock record的指针，此时只使用CAS自旋操作去进行抢锁，而不是直接用重量级锁，也降低了资源消耗。

### 介绍一下锁膨胀的过程
首先在没有线程访问的情况下，资源处于无锁状态， 当有且仅有一个线程过来访问了，这是线程会判断资源的MarkWord是否存储了线程ID，如果没存储就修改为自己的线程ID，如果存储了就判断是否为自己的线程ID，是就直接进入执行。而当第二个线程进来的时候，此时它判断MarkWord的线程ID不是自己的，~~（就会使用CAS操作进行修改，修改成功就执行，修改失败则代表发生竞争，）~~此时就会发生锁膨胀，等待占有线程走到安全点时，会触发STW，然后判断线程是否执行完成，若执行完成，就释放偏向锁，即将MarkWord修改为默认值，然后线程B就可以重新获得偏向锁，如果执行未完成，则膨胀为轻量级锁，通过CAS自旋去竞争，当自旋失败达到一定次数时，再膨胀为重量级锁。

### 什么是适应性自旋锁？synchronized里面怎么使用了自旋锁/适应性自旋锁？
就是在自旋操作中的自旋次数是自适应的，由前一次在同一个锁上的自旋时间和拥有者的状态共同决定。

例如前一次线程很快通过自旋操作获得了锁，那么认为自旋很可能能够得到锁，就允许更长的自旋时间

### 什么是锁消除？
### 什么是锁粗化？
### <font style="color:rgb(44, 62, 80);">synchronized的使用？</font>
synchronized可以用来修饰方法和代码块

当synchronized修饰实例方法时，锁的是当前对象，进入同步代码需要获得当前对象的锁。而当synchronized修饰的是静态方法时，锁的是类，进入同步代码需要获得当前类的锁。修饰方法时，会在方法的字节码中加入一个ACC_SYNCHRONIZED标识，来说明当前方法是同步方法。

当synchronized修饰代码块时，可以锁对象或者类。修饰代码块时，是在字节码中代码块前添加monitorenter，代码块后添加monitorexit，代表同步代码的开始和结束。

### <font style="color:rgb(44, 62, 80);">构造方法可以用 synchronized 修饰么？</font>
构造方法不可以用synchronized来修饰。构造方法本身就是线程安全的，不存在同步的构造方法。

### <font style="color:rgb(44, 62, 80);">synchronized 底层原理了解吗？</font>
synchronized在修饰代码块的时候，是在字节码中代码块前添加monitorenter，代码块后添加monitorexit，代表同步代码的开始和结束。当执行monitorenter的时候，线程久长时获取monitor，此时会判断锁的计数器是否为0，为0则获取，并加1，不为0则获取失败。当对象锁的拥有者执行monitorexit的时候，就会释放锁，并将锁的计数器减1，计数器为0则释放成功。

修饰方法时，会在方法的字节码中加入一个ACC_SYNCHRONIZED标识，来说明当前方法是同步方法。然后本质上同样是去获取monitor。

### <font style="color:rgb(44, 62, 80);">JDK1.6 之后的 synchronized 底层做了哪些优化？</font>
<font style="color:rgb(44, 62, 80);">偏向锁、轻量级锁、自旋锁、适应性自旋锁、锁消除、锁粗化等技术。锁主要存在四种状态：无锁状态、偏向锁、轻量级锁、重量级锁，随着竞争越来越激烈，锁的状态会发生膨胀升级，这样设计是为了提高获得锁和释放锁的效率。</font>

### <font style="color:rgb(44, 62, 80);">synchronized 和 volatile 有什么区别？</font>
1. synchronized可以用来修饰代码块和方法，而volatile只能修饰变量。
2. volatile只能保证多线程下共享资源的可见性，不能保证原子性，而synchronized两者都可以保证。
3. volatile关键字主要用于解决变量在多线程之间的可见性问题，而synchronized则用来解决多线程之间资源访问的同步性。

### <font style="color:rgb(44, 62, 80);">synchronized有什么缺陷？</font>
耗时、消耗资源、只能阻塞等待、性能低、无法知道是否成功获取锁

### <font style="color:rgb(44, 62, 80);">Synchronized在使用时有何注意事项?</font>
锁对象不能为空

作用域不能过大

避免产生死锁

## Atomic原子类
### 什么是原子类？介绍一下原子类？
原子类就是java中具有原子性的一个类，它可以用来实现一些原子操作。常用的包括AtomicInteger，AtomicLong，还有对应的数组类型比如AtomicIntegerArray，还有对于引用类型的AtomicReference，AtomicStampedReference等。我们可以通过它提供的一些方法来实现原子操作，比如AtomicInteger我们可以调用getAndIncrement执行自增操作。他还包括了对象的属性修改类型原子类，主要用来对对象的某个字段实现原子更新操作。

### 原子类是怎么实现的？原子类有什么优势？
原子类的底层是利用CAS+volatile和native方法来实现的，通过CAS保证了操作的原子性，而volatile 则保证任何时刻任何线程看到的value都是最新值。

### AtomicStampedReference和AtomicMarkableReference有什么区别？
AtomicStampedReference是用来解决CAS的ABA问题的，它使用版本号机制进行解决，每次CAS会将版本号+1，而AtomicMarkableReference也类似，但他使用的是一个boolean标记，通过true和false来区分。

### LongAddr
longaddr是JDK1.8新增的一个类。在之前的原子类当中，是基于CAS操作来实现原子性的，但是当并发量大起来之后，频繁的重试会大量消耗CPU资源，因此Longaddr就是为了解决这个问题，它采用了分段锁的思想，每个线程在不同的位置进行累加，提高了整体的并发量。

具体而言，longaddr方法中包含一个base变量和一个cell数组，当不存在竞争时，线程直接在base上进行累加，当存在竞争时，即一个线程CAS操作失败时，就会对cell数组进行初始化，并且根据当前线程的hash值映射到相应槽位，并执行cas操作更新当前槽位的值，若更新失败则会调用longaccumulate方法对数组进行扩容。在扩容过程中，也是使用CAS操作，如果数组正在扩容，则会直接尝试在base上进行增加。（初始容量为2，两倍扩容）

<!-- 这是一张图片，ocr 内容为：START (说明未出现过并发冲突) CELL口是否初始化? 否 直接CAS更新BASE值 再次判断CELI[]是否初始 END 更新BASE成功? 化? (说明出现了并发冲突) CAS更新CEL1单元中的数值 CAS更新CE11单元成功? (根据当前线程的HASH数映射 到CELL[数组的指定槽位) (说明存在多个线程的 HASH值映射到了同一 个槽位,并发操作导 致CAS失败) 调用STRIPED64的 否 LONGACCUMULATE方法 知乎@XJ20116921 END2 -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1677678311864-ce4f1f65-2055-4735-81fb-569fef9222fd.png)

<!-- 这是一张图片，ocr 内容为：START CELL口是香已经初始化完 尝试将当前数值直接累加到 当前线程HANB值映射的 一一一之 CELL口是否正在初始化? BESE基数 尝试CAS更新CELL单元值 捡告是否成功? 更新或功? 会试加镜并移始化CELI口数组 (初始大小2),然后给当前线 程分配一个CELL单元 CAS更新BAO 基数成功? (数值购到CE11单元中) 是否能进行扩容? (CELI日大小<CT核数 时才能护容 初始化CELL日成功? 开始进行扩容.CELL目扩容后 的大小为原来的2售 知乎@XJ20116921 END -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1679234350816-475f15d4-a81f-4e5d-b31e-dcbcff2cc388.png)

## <font style="color:rgb(44, 62, 80);">ReentrantLock</font>
### 什么是ReentrantLock？
ReentrantLock是Java中的一个可重入且独占式的锁，它实现了Lock接口，类似于synchronized，不过更加灵活，它增加了轮询、超时、中断、公平锁和非公平锁等操作。它有一个内部类sync，sync继承于AQS，添加锁和释放锁的大部分操作都是在sync中实现的。sync还有公平锁fairsync和非公平锁nonfairsync两个子类。

### 什么是可重入锁？
可重入锁也叫递归锁，它指的就是线程能够再次获得自己的内部锁，就是说当一个线程拥有一个对象锁时，当其想要再次获得该对象的锁，是可以获得的，如果不是可重入锁的话，就会造成死锁。

### <font style="color:rgb(44, 62, 80);">公平锁和非公平锁有什么区别？</font>
公平锁就是按照申请的先后顺序来获得锁，先申请的线程先得到锁，从而保证了时间上的有序，但是会导致上下文切换频繁，降低性能。

非公平锁就是锁释放之后不按照顺序，而是随机抢夺，因此后申请的线程可能会先得到锁，这样性能更好，但可能导致某些线程一直得不到锁。

### <font style="color:rgb(44, 62, 80);">synchronized 和 ReentrantLock 有什么区别？</font>
1. synchronized和reentrantlock都是可重入锁。
2. synchronized依赖于jvm来实现，而reentrantlock是jdk层面的实现，需要使用lock和unlock方法配合try/finally来完成加锁和释放锁操作。
3. reentrantlock比synchronized多了一些高级操作：
    1. 公平锁和非公平锁：reentrantlock可以通过构造方法指定是非公平锁还是公平锁，而synchronized只能是非公平锁。
    2. 等待可中断：reentrantlock可以通过lock.lockInterruptilby()来实现中断等待所的线程，就是说正在等待的线程可以放弃等待，去做别的事。
    3. 选择性通知：reentrantlock可以通过Condition接口和newCondition方法来实现选择性通知。多个线程对象可以注册到指定的condition当中，从而有选择的进行线程通知。而notify/notifyAll则是由jvm选择通知的线程。

## 读写锁
### <font style="color:rgb(44, 62, 80);">ReentrantReadWriteLock</font>
ReentrantReadWriteLock是一个可重入的读写锁，它实现了ReadWriteLock，它既可以保证多线程读的效率，也可以保证多线程写的安全。他包含一个ReadLock和一个WriteLock。读锁是共享锁，而写锁是独占锁。他也是基于AQS实现的，对于state，它的高16位用来记录读线程数，而低16位用来记录写线程重入次数

### <font style="color:rgb(44, 62, 80);">ReentrantReadWriteLock 适合什么场景？</font>
<font style="color:rgb(44, 62, 80);">ReentrantReadWriteLock能够保证多线程读的效率，也能够保证多线程下写的安全，因此在读多写少的场景下能够明显提升系统性能。</font>

### 什么是读写锁?
读写锁就是读读时不互斥，读写、写写时互斥，而一般锁都是互斥的。

### 共享锁和独占锁是什么？
共享锁就是一把锁可以被多个线程同时获得

独占锁就是一把锁只能被一个线程获得

### <font style="color:rgb(44, 62, 80);">线程持有读锁还能获取写锁吗？</font>
线程持有读锁时，是不能获取写锁的，因为在获取写锁时，如果读锁被线程持有，就会直接获取失败，不论读锁是哪个线程持有。

而线程持有写锁时，是能够获取读锁的，只有写锁被其他线程占有时，才不能获取读锁。

### <font style="color:rgb(44, 62, 80);">读锁为什么不能升级为写锁？</font>
写锁可以降级为读锁，但读锁不能升级为写锁。因为写锁时独占锁，如果读锁升级为写锁就会引起线程争夺，影响性能，而且可能导致死锁。比如两个线程都想升级，但都需要等待对方释放锁。

当一个线程拥有写锁的时候，再去获得读锁，是可以获得的，这时候会发生写锁的锁降级。锁降级机制可以保证自己线程的写操作一定 是对自己可见、可用的。如果不能获得读锁，需要先释放写锁，再获得读锁，那么可能再获得读锁前，被其他线程抢占修改，就会导致问题。

### <font style="color:rgb(44, 62, 80);">StampedLock 是什么？</font>
stampedlock是jdk1.8引入的性能更好的读写锁，其不可重入且不支持条件变量condition。它是基于CHL独立实现的。它支持三种读写控制模式：写锁、读锁和乐观读。

写锁：独占锁，不可重入

读锁：共享锁但悲观，如果有其他线程持有写锁，则阻塞直到写锁释放，不可重入

乐观读：共享锁，乐观，多个线程可以持有该锁，且允许一个写线程持有写锁。

### 为什么是不可重入的？如何实现？
stampedlock在获取锁的时候会返回一个long型的数据戳，该数据戳用于稍后的锁释放参数，如果返回0则代表获取失败。而当线程持有后再次获取，依然会返回一个新的数据戳，因此是不可重入的。

### <font style="color:rgb(44, 62, 80);">StampedLock 的性能为什么更好？</font>
主要还是由于乐观读，能够保证有一个写线程进行写操作，因此在读多写少的场景下能够让写线程有机会获得锁，减少饥饿问题，提高吞吐量。

### 乐观读是如何执行的？
首先在尝试获取乐观读锁的时候，会返回一个stamp，如果为0，说明此时有写线程再执行，获取失败，如果不为0则获取成功，然后拿stamp再次验证，成功则执行代码。

### <font style="color:rgb(44, 62, 80);">StampedLock 适合什么场景？</font>
读多写少

### <font style="color:rgb(44, 62, 80);">StampedLock 的底层原理了解吗？</font>
stampedlock基于CHL实现。介绍CHL。

### StampedLock写锁的tryAcquire、tryRealease
<!-- 这是一张图片，ocr 内容为：开始 获取当前线程 获取状态 计算写锁数量 是 写线程是否 状态是否为 应该被阻塞 0 否 否 是 写锁数量是 否 比较设置状 否为0 态是否成功 是 否 设置独占线程为当前线程 否 是否为当前 线程独占 返回 是 否 是否超过最 抛出异常 设置状态 大写锁数量 -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1677764768474-9d1c3423-c756-4030-a2fb-ceffc97b791a.png)

<!-- 这是一张图片，ocr 内容为：开始 否 是否为当前 线程独占 是 计算下一个状态 抛出异常 写锁数量是 否为0 是, 设置独占线程为空 设置状态 返回 -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1677764628482-0030c726-761b-4f4f-a2eb-7dfd1c2cde7a.png)

### StampedLock读锁的tryAcquire、tryRealease
<!-- 这是一张图片，ocr 内容为：开始 读锁是否为0 是 获取当前线程 设置第一个读线程 获取状态 设置第一个读线程计数 否 写锁是否为0 否 当前线程是否为 是 第一个读线程 是 否 当前线程是 否独占资源 增加第一个读线程计数 是 返回 获取读锁数量 获取缓存计数器 是 读线程是否 被阻塞 缓存线程计数 器是否为空 否 否 读锁数量是否 否 小于最大值 是 缓存线程计数器TID是否 设置当前线程计数器 与当前线程的TID相等 比较设置是 否成功 获取当前线程的计数器 增加计数器计数 进入FULLTRYACQUIRESHARED -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1677765009635-2ada55b9-05bd-4f01-8ded-73e936ac00b7.png)

<!-- 这是一张图片，ocr 内容为：开始 获取缓存计数器 获取当前线程 是 缓存线程计数 器是否为空 否 当前线程是否为 否 第一个读线程 是 缓存线程计数器TID是否 与当前线程的TID相等 第一个读线程计 减少第一个读线程的计数 数是否为1 获取当前线程的计数器 设置第一个读线程为空 否 计数器的计数 是否小于等于1 获取状态 是 计算下一个状态 移除当前线程的计数器 是 比较设置状 计数器的计数 抛出异常 态是否成功 是否小于等于0 否 减少计数 返回 -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1677765014133-2aded7ba-f28f-47ec-bd74-fc6bfa2d4c8a.png)

## <font style="color:rgb(44, 62, 80);">ThreadLocal</font>
### <font style="color:rgb(44, 62, 80);">什么是ThreadLocal？ThreadLocal 有什么用？</font>
ThreadLocal主要解决的就是让线程能够有自己的本地私有变量，当用ThreadLocal修饰一个变量时，访问该变量的线程就能够持有一份该变量的本地副本，并且可以通过get和set方法获取默认值或将值设为本地副本的值，从而避免线程安全问题。并且不需要加锁

### <font style="color:rgb(44, 62, 80);">ThreadLocal 原理了解吗？</font>
ThreadLocal里边有一个重要的静态内部类叫做ThreadLocalMap， 他就是一个map的数据结构，用来存储以threadlocal为key，要存的值为value的键值对，而在Thread类里边，又有一个threadlocalmap类型的对象，也就相当于说每一个线程都拥有一个属于自己的threadlocalmap，在放值的时候就会往自己的map里面放，取值也从map中取。threadlocalmap底层则由一个数组存储entry实现。

### <font style="color:rgb(44, 62, 80);">ThreadLocal 内存泄露问题是怎么导致的？</font>
ThreadLocalMap中key存储的ThreadLocal使用弱引用，而value存储的值使用强引用来解决内存泄漏问题。如果两者都是强引用的话，当线程执行完成，线程这里对于ThreadLocal的强引用断开，但是ThreadLocalMap对该ThreadLocal仍然有强引用，导致ThreadLocal不会被回收，就会造成内存泄漏。而换成弱引用的话，一旦线程对ThreadLocal的强引用断开，那么弱引用自然就会回收。但是这样的话会产生key为null的entry，可能会导致value永远无法被回收。因此ThreadLocalMap在get、set、remove方法时都会清理掉key为null的entry。

### 解释一下ThreadLocal.set方法的原理
首先set方法会获取当前线程，然后获取当前线程的map，判断该map是否为空，如果为空则创建map，并set，如果不为空就直接set。在具体的threadlocalmap.set方法中，首先会进行key的hash计算，得到对用的插入位置，如果位置上为空，则直接插入，如果位置上不为空，先判断key是否相同，相同则替换，如果不同就会向后遍历，在遍历过程中，如果碰到key相同的就会替换，如果碰到key为null的，说明这是一个需要被回收的节点，则会调用一个replace方法执行一些清理操作和插入新节点，如果碰到null的话，则会直接插入该位置。并调用一个clean方法进行启发式清理。

### 解释一下replaceStaleEntry的过程
当我们遇到一个key为null的节点时，就会调用replace方法进行操作，在这个方法中，首先会记录当前节点位置为staleSlot，然后向前遍历，寻找第一个需要被清理的slot位置，然后再向后遍历，遍历过程中如果找到和插入的key相同的key就将该位置和staleSlot交换，并更新值。同时如果在staleSlot之前没有垃圾节点的话，这里也要更新一下第一个slot的位置。然后就会进行清理操作。然后如果碰到null位置，就结束遍历，直接砸死staleSlot位置插入，然后开启清理操作。

### 解释一下ThreadLocalMap清理过期key的原理
ThreadLocalMap的清理过程包括探测式清理和启发式清理两个部分。探测式清理就是从清理的起始位置开始，向后清理，当碰到key为null的entry时就将他清理（value=null），如果碰到没过期的数据，则会对其进行rehash，重新定位并插入，使得它更接近自己正确的位置。一直清理到碰到null，退出。

启发式清理就是试探性的扫描一些单元格，寻找过期元素。通过一个while不断右移，寻找过期元素，最终都会调用探测式清理进行清理。

### <font style="color:rgb(44, 62, 80);">ThreadLocalMap扩容机制</font>
首先当执行完set方法后，如果执行完启发式清理没有清理任何数据，并且列表的entry数量已经达到了阈值threshold，那么就调用rehash方法，在rehash方法中会首先进行一次探测式清理，然后再次判断清理之后的entry数量是否大于阈值的四分之三，如果还大于，就调用resize进行扩容，扩容是两倍扩容，扩容之后会重新计算entry的hash，重新散列。

### 解释一下get方法？
get方法首先计算key的hash值，定位到对应的entry，然后判断当前entry的key是否相等，相等则返回，不相等则向后遍历查找，遍历过程中如果碰到key为null的entry，则会触发一次探测式清理，直到找到key相等或找到null。

### ThreadLocal有什么注意事项？
1. 脏数据，可能由于线程复用，产生脏数据，应该在代码中显式的remove来避免
2. 内存泄漏，也应该remove来避免
3. 子线程不能获得父线程本地变量副本，可以使用inheritableThreadLocal

### 什么是inheritableThreadLocal？有什么用？
inheritableThreadLocal主要解决的是子线程不能获得父线程的本地变量副本的问题。它的解决方法就是在new Thread的时候，构造方法会调用init方法，将父线程的inheritableThreadLocal复制过来，从而实现。但是这种做法在线程池中会存在一个问题，因为线程池的线程是会复用的。<font style="color:rgb(44, 62, 80);">阿里巴巴开源了一个</font><font style="color:rgb(44, 62, 80);">TransmittableThreadLocal</font><font style="color:rgb(44, 62, 80);">组件就可以解决这个问题。</font>

### <font style="color:rgb(44, 62, 80);">ThreadLocal有哪些使用场景？</font>
1. 为每个线程分配一个JDBC连接的connection，<font style="color:rgb(77, 77, 77);">保证每个线程的都在各自的 Connection 上进行数据库的操作。</font>
2. <font style="color:rgb(77, 77, 77);">用户信息的传递</font>

## 线程池
### <font style="color:rgb(44, 62, 80);">什么是线程池?</font>
线程池就是管理一系列线程的资源池，当有任务需要处理时就从线程池中获取线程来处理，处理完之后线程并不会立即销毁，而是等待下一个任务。

### <font style="color:rgb(44, 62, 80);">为什么要用线程池？</font>
线程池是一种限制和管理线程资源的方式。并且能够记录一些基本的统计信息，如已完成的线程数量等。主要有几个优点:

+ 降低资源消耗：线程池能够重复利用已创建的线程，从而降低线程创建和销毁带来的消耗。
+ 提高响应速度：一旦有任务提交可以立即开始执行，不用等待线程创建。
+ 提高资源的可管理性：利用线程池能对线程进行统一的分配、调优和监控

### <font style="color:rgb(42, 41, 53);background-color:rgb(253, 253, 253);">线程池解决的问题是什么</font>
线程池主要解决三个问题：

频繁申请、销毁线程带来的巨大开销

无限申请线程带来的资源耗尽风险

系统无法合理管理内部资源分布，降低稳定性

### <font style="color:rgb(44, 62, 80);">如何创建线程池？</font>
1. 使用ThreadPoolExecutor构造函数创建（int nThreads, int nThreads, long keepAliveTime, TimeUnit, BlockingQueue<Runnable>）
2. 使用Executors创建（Executors.newFixedThreadPool(nThreads)）

### 线程池的使用？
首先创建ThreadPoolExecutor对象，并调用execute或submit方法，传入一个实现runnable或callable的对象，从而执行任务。使用submit方法的话会返回一个futuretask对象，可以通过执行futuretask.get来获得任务结果。

### 线程池如何维护运行状态?
线程池内部是利用一个原子变量来维护状态的，这个变量的高3位保存运行状态，低29位保存线程数量。用一个变量来维护两个状态可以省去同步的开销。而且可以采用位运算去获取信息，速度更快。

### 线程池如何实现线程管理？
线程池主要就是使用Worker类来实现线程创建和获取任务。worker类是一个内部类，它主要持有一个线程和一个firstTask，用来保存第一个任务，这个可以为null。

然后线程池会维护一个hashset去持有线程，来实现对线程生命周期的管理。主要就是要判断线程的状态，判断状态主要依赖于worker是继承AQS的，独占式且不可重入，一旦执行lock方法，就代表线程正在运行，不应该回收，如果不是独占锁状态，则为空闲，可以回收。

在new一个woker的时候，会先设置其state为-1，代表正在创建，还不可中断，创建完成后先执行一次unlock，修改state为0，当线程执行时，会调用lock方法将state改为1，执行结束unlock

### 为什么worker要是不可重入的？
因为要利用不可重入的特性去进行线程管理。如果是可重入的话，再执行一些比如setCorePoolSize这样的操作，就会导致可重入获得锁，执行中断操作。

worker类加锁的目的主要是 要求线程中断时必须先获取锁，防止任务还没运行完。

### <font style="color:rgb(0, 0, 0);background-color:rgb(253, 253, 253);"> Worker线程怎么回收？</font>
worker线程的回收主要靠jvm垃圾回收，当我们要回收一个线程的时候，把对他的引用断掉就好了。

### worker线程执行任务流程？
<!-- 这是一张图片，ocr 内容为：开始 申请任务 是否申请到了新任务 是 申请WORKER非重入锁 线程池是否处于 线程中断 STOP后的状态 否 执行任务 释放WORKER非重入锁 循环/重新申请新任务 任务结束 销毁线程 结束 -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1677772441420-cadc5d19-ccbc-493b-8d1c-50a14034f212.png)

### <font style="color:rgb(44, 62, 80);">线程池常见参数有哪些？如何解释？</font>
+ `corePoolSize`: 线程池需要保持corePoolSize个线程，不论他们是否空闲
+ `maximumPoolSize`: <font style="color:rgb(34, 34, 34);">线程池中最多允许创建的线程数</font>
+ `workQueue`：任务队列，新来的任务会判断是否达到核心线程数，达到则放入队列等待
+ `keepAliveTime`：当线程池的线程数大于核心线程数时，如果没有任务提交，非核心线程会在等待keepAliveTime后销毁
+ `unit`：keepAliveTime的时间单位
+ `threadFactory`：创建新线程用的
+ `handler`：饱和策略

<!-- 这是一张图片，ocr 内容为：线程池 核心线程 任务队列 COREPOOLSIZE 当线程数大于核心线程数时,多余的空闲 线程的存活的最长时间为KEEPALIVETIME 非核心线程 MAXIMUMPOOLSIZE -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1676966783680-ed0363f1-1671-437b-a917-c51634d1dc2a.png)

### <font style="color:rgb(44, 62, 80);">为什么不推荐使用内置线程池？（为什么推荐使用线程池）</font>
线程池能够减少创建和销毁线程的开销，解决资源不足问题，避免系统创建大量的同类线程而导致内存消耗完或过度切换问题。

### 线程池中的keep alive time是怎么工作的?
在获取任务时，对于非核心线程，会使用poll方法阻塞获取，等待keep alive time 的时间，如果超时都没获取到任务，则会回收该线程。代码如下：

```java
// Are workers subject to culling? 允许核心线程回收或当前为非核心线程时，为true
boolean timed = allowCoreThreadTimeOut || wc > corePoolSize;

if ((wc > maximumPoolSize || (timed && timedOut))
    && (wc > 1 || workQueue.isEmpty())) {
    if (compareAndDecrementWorkerCount(c))
        return null;
    continue;
}

try {
    // 这一步是关键，需要了解poll和take的区别，take会进行阻塞。
    //当需要判断是否超时时，使用poll方法
    Runnable r = timed ?
        workQueue.poll(keepAliveTime, TimeUnit.NANOSECONDS) :
        workQueue.take();
    if (r != null)
        return r;
    timedOut = true;
} catch (InterruptedException retry) {
    timedOut = false;
}
```

### Executors的弊端
Executors的弊端主要源于他不能对线程池的等待队列做一些参数设置，而是使用默认值。

+ FixedThreadPool和SingleThreadExecutor：使用的是无界队列LinkedBlockingQueue，最大队列长度为Integer.MAX_VALUE，可能导致堆积大量的请求，导致OOM
+ ScheduledThreadPool和SingleThreadScheduledExecutor：使用的无界延迟阻塞队列DelayedWorkQueue，最大队列长度为Integer.MAX_VALUE，可能导致堆积大量的请求，导致OOM
+ CachedThreadPool：使用的是同步队列SynchronousBlockingQueue，允许创建的线程数为Integer.MAX_VALUE，可能创建过多的线程，导致OOM

### <font style="color:rgb(44, 62, 80);">线程池的饱和策略有哪些？</font>
`<font style="color:rgb(44, 62, 80);">ThreadPoolExecutor.AbortPolicy</font>`<font style="color:rgb(44, 62, 80);">：抛出异常来拒绝新的任务（RejectedExecutionException）</font>

`<font style="color:rgb(44, 62, 80);">ThreadPoolExecutor.CallerRunsPolicy</font>`<font style="color:rgb(44, 62, 80);">：调用执行Execute方法的线程来执行被拒绝的任务，如果执行程序已关闭，则丢弃该任务</font>

`<font style="color:rgb(44, 62, 80);">ThreadPoolExecutor.DiscardPolicy</font>`<font style="color:rgb(44, 62, 80);">：直接丢弃该任务</font>

`<font style="color:rgb(44, 62, 80);">ThreadPoolExecutor.DiscardOldestPolicy</font>`<font style="color:rgb(44, 62, 80);">：丢弃最早未处理任务</font>

### <font style="color:rgb(44, 62, 80);">线程池常用的阻塞队列有哪些？</font>
+ 有界队列
+ 无界队列`LinkedBlockingQueue`：队列容量为Integer.MAX_VALUE，队列不会被放满，因此只能放满核心线程数。常用的有FixedThreadPool和SingleThreadExecutor使用。
+ 同步队列`SynchronousQueue`：没有队列容量，当新任务来的时候，判断是否有空闲线程可运行，没有就创建一条新的线程，因此可以创建Integer.MAX_VALUE条线程，容易导致OOM。常用的有CachedThreadPool
+ 延迟阻塞队列`DelayedWorkQueue`：其内部元素不是按照时间顺序排序，而是按照延迟时间的大小进行排序，采用堆数据结构，能保证每次出队的数据都是执行时间靠前的任务。当堆节点达到容量的一半时进行扩容，最大容量为Integer.MAX_VALUE，因此和LinkedBlockingQueue一样会导致OOM

<!-- 这是一张图片，ocr 内容为：名称 描述 1一个用数组实现的有界阻塞队列,此队列按照先进先出(FIFO)的原则对元素进行排序.支持公平锁和非公平锁. ARRAYBLOCKINGQUEUE 一个由链表结构组成的有界队列,此队列按照先进先出(FIFO)的原则对元素进行排序.此队列的默认长度为 LINKEDBLOCKINGQUEUE INTEGER.MAX_VALUE,所以默认创建的该队列有容量危险. 一个支持线程优先级排序的元界队列,默认自然序进行排序,也可以自定义实现COMPARETOO方法来指定元素排 PRIORITYBLOCKINGQUEUE 序规则,不能保证同优先级元素的顺序. I一个实现PRIORITYBLOCKINGQUEUEUEUEUE实现的无界队列,在创建元素时,可以指定多久才能从队列中获取当 DELAYQUEUE 前元素.只有延时期满后才能从队列中获取元素. 一个不存储元素的阻塞队列,每一个PUT操作必须等待TAKE操作,香则不能添加元素.支持公平锁和非公平锁. [SYNCHRONOUSQUEUE的一个使用场景是在线程池里.EXECUTORS.NEWCACHEDTHREADPOOLO就使用了 SYNCHRONOUSQUEUE ISYNCHRONOUSQUEUE.这个线程池根据需要(新任务到来时)创建新的线程.如果有空闲线程则会重复使用. 线程空闲了60秒后会被回收. 1一个由链表结构组成的无界阻塞队列,相当于其它队列,LINKEDTRANSFERQUEUE队列多了TRANSFER和 LINKEDTRANSFERQUEUE TRYTRANSFER方法. 一个由链表结构组成的双向阻塞队列.队列头部和尾部都可以添加和移除元寨,多线程并发时,可以将锁的竞争 LINKEDBLOCKINGDEQUE 最多降到一半. -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1677770700462-dd879adb-3b6d-4f7c-9a1f-ef8dea34a523.png)

### 阻塞队列和普通队列有什么区别？是如何实现阻塞的？
阻塞队列为我们提供了一些列的阻塞式获取、插入和删除的方法，包括抛出异常、线程阻塞、返回特定值、超时这几类。

<!-- 这是一张图片，ocr 内容为： -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1694349810470-b8919ad9-9f27-4b6c-bf98-140c8c80219d.png)

从实现上来说，不同的队列可能有不同的实现方式。以ArrayBlockingQueue为例，它使用Reentrantlock和condition实现阻塞：

```java
public class ArrayBlockingQueue<E> extends AbstractQueue<E>
        implements BlockingQueue<E>, java.io.Serializable {

    private static final long serialVersionUID = -817911632652898426L;

    //存储元素的数组
    final Object[] items;

    //获取元素时的索引
    int takeIndex;

    //插入元素时的索引
    int putIndex;

    /** Number of elements in the queue */
    int count;

    /** Main lock guarding all access */
    final ReentrantLock lock;

    /** 为空时获取，使用该condition进行await */
    private final Condition notEmpty;

    /** 队列满时插入，使用该condition进行await */
    private final Condition notFull;

    /**
     * Shared state for currently active iterators, or null if there
     * are known not to be any.  Allows queue operations to update
     * iterator state.
     */
	//用于实现迭代器
    transient Itrs itrs = null;
	//...
}
```

1. **put**：

```java
public void put(E e) throws InterruptedException {
    //不允许插入空值，因此先判断不为空
    checkNotNull(e);
    final ReentrantLock lock = this.lock;
    //获取锁
    lock.lockInterruptibly();
    try {
        //此时代表队列满
        while (count == items.length)
            //则使用notFull进行await，同时会释放lock
            notFull.await();
        //执行入队
        enqueue(e);
    } finally {
        lock.unlock();
    }
}

private void enqueue(E x) {
    final Object[] items = this.items;
	//插入元素
    items[putIndex] = x;
	//如果到了列表尾，则再从头开始，相当于一个循环列表
    if (++putIndex == items.length)
        putIndex = 0;
    count++;
	//插入完成，唤醒阻塞在“队列为空”的线程
    notEmpty.signal();
}
```

2. **get：**

```java
public E take() throws InterruptedException {
    final ReentrantLock lock = this.lock;
    lock.lockInterruptibly();
    try {
        //如果队列为空
        while (count == 0)
            //则阻塞在“队列为空”
            notEmpty.await();
        return dequeue();
    } finally {
        lock.unlock();
    }
}

private E dequeue() {
    // assert lock.getHoldCount() == 1;
    // assert items[takeIndex] != null;
    final Object[] items = this.items;
    @SuppressWarnings("unchecked")
    E x = (E) items[takeIndex];
    items[takeIndex] = null;
    if (++takeIndex == items.length)
        takeIndex = 0;
    count--;

    if (itrs != null)
        itrs.elementDequeued();
    notFull.signal();
    return x;
}
```

### 还有其他什么实现方式？有什么区别？
wait/notifyAll的方式。相比之下，notifyAll是唤醒所有线程再去抢锁，会带来更大的上下文切换开销，而condition可以精准的唤醒阻塞在插入或获取的线程，开销更小。

### 线程池有几种状态？
<!-- 这是一张图片，ocr 内容为：SHUTDOWN 队列为空,并且线程池 中执行的任务也为空 SHUTDOWN() TERMINATED()执行完毕! TIDYING TERMINATED RUNNING SHUTDOWNOW() 线程池中执行的任务为空 STOP -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1677769922541-bb83a76c-1f91-4110-a5e9-b9bd0205c50d.png)

<!-- 这是一张图片，ocr 内容为：状态描述 运行状态 RUNNING 能接受新提交的任务,并且也能处理阻塞队列中的任务. 关闭状态,不再接受新提交的任务,但却可以继续处理阻塞队列中已保存的任务. SHUTDOWN 不能接受新任务,也不处理队列中的任务,会中断正在处理任务的线程. STOP 所有的任务都已终止了,WORKERCOUNT(有效线程数)为0. TIDYING 在TERMINATED()方法执行完后进入该状态. TERMINATED -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1677770607774-c8f14e31-5bb0-4b7a-9bbd-d3fd6034750c.png)

### <font style="color:rgb(44, 62, 80);">线程池处理任务的流程了解吗？</font>
首先我们向线程池提交一个任务，判断核心线程池是否已满，如果未满就创建线程执行任务，如果满了的话，就判断线程池是否处于运行状态，并尝试将任务加到队列当中，这里会二次判断线程池的运行状态，然后如果工作线程数量为0的话，就会创建一个非核心线程，并传入参数为null。如果入队失败，即队列已满，就会尝试创建非核心线程传入任务执行，如果创建非核心线程也失败，就会执行拒绝策略。

<!-- 这是一张图片，ocr 内容为：HANDLER 提交任务 执行拒绝策略 EXECUTE() CALLERRUNS POLICY WORKERS 是否达到最 队列是 是否达到核 DISCARDOLDEST 大线程数 否已满 心线程数 POLICY MAXIMUNPOOL COREPOOL N TZ DISCARDPOLICY WORKER 创建工作线程 创建工作线程 加入阻塞队列 ADDWORKER() ADDWORKER() ABORTPOLICY WORKER 启动工作线程 WORKER.THREAD WORKER OFFER() WORKQUEUE START() RUNNABLE RUNNABLE RUNNABLE RUNNABLE 开启工作任务 RUNWORKER() POLL(KEEPALIVETIME,TIMEUNIT) 获取任务 TAKE() 是否需要超时 GETTASK() 销毁线程 是否获取 执行任务 PROCE照乎新@世界员因辉 到任务 TASK.RUN() -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1677057085633-33ec7851-40e6-475f-8793-8aca2ffe179f.png)

### <font style="color:rgb(44, 62, 80);">如何给线程池命名？</font>
setName

### <font style="color:rgb(44, 62, 80);">如何设定线程池的大小？</font>
线程池过小可能会导致过多的任务堆积在等待队列上，导致OOM

线程池过大可能会导致过多的线程同时争抢CPU，上下文切换频繁，降低性能

线程池大小的设定通常有两种：

CPU任务密集采用N+1的方式：当任务大多是占用CPU时，可以采用N+1方式，N为CPU核心数，多一个线程是为了在线程出现一些问题（如缺页中断）而导致任务暂停时，CPU不运行带来的影响，多一个线程的话此时CPU就可以运行这个线程。

IO任务密集采用2N方式，因为系统在处理IO任务时并不会占用CPU，因此可以多设定一些线程，提高CPU利用率。

### <font style="color:rgb(44, 62, 80);">如何动态修改线程池的参数？</font>
可以使用setCorePoolSize和setMaximumPoolSize来修改这两个参数，修改corepoolsize时，线程池会先判断当前工作线程数量是否大于corePoolSize，如果大于的话，就会回收工作线程。修改maximumpoolsize也类似，如果工作线程大于最大线程数，会回收工作线程。

对于workQueue，我们可以自定义一个队列，将原本队列的final int capacity去掉final，然后提供相应的set方法就可以修改。

<!-- 这是一张图片，ocr 内容为： -->
![](https://cdn.nlark.com/yuque/0/2023/png/34998771/1676976298820-bf7ee479-5e22-4d86-8cf8-95bd34a6fdab.png)

### 线程池中线程抛出异常了会怎么样？
<font style="color:rgb(18, 18, 18);">1、execute方法,可以看异常输出在控制台，而submit在控制台没有直接输出，必须调用Future.get()方法时，可以捕获到异常。</font>

<font style="color:rgb(18, 18, 18);">2、一个线程出现异常不会影响线程池里面其他线程的正常执行。</font>

<font style="color:rgb(18, 18, 18);">3、线程不是被回收而是线程池把这个线程移除掉，同时创建一个新的线程放到线程池中。</font>

<font style="color:rgb(18, 18, 18);">4、可以设置</font><font style="color:rgb(68, 68, 68);">uncatchexceptionhandler处理，不过线程还是会被清理掉，新建一个线程到线程池中。
</font><font style="color:rgb(68, 68, 68);">原因：processWorkerExit是在finally中执行的，所以线程执行只要抛出异常，就会执行processWorkerExit，和是否设置了uncatchexceptionhander没有关系</font>

### <font style="color:rgb(68, 68, 68);">为什么线程崩溃了不会导致JVM崩溃</font>
正常情况下，操作系统为保证系统安全，会为非法内存访问发送一个SIGSEGV信号。在操作系统中默认的信号处理函数会让该进程崩溃，但有时直接让进程崩溃代价太大，所以可以自定义一个信号处理函数去灵活处理，JVM就是这么做的。

像空指针异常、栈溢出这些问题比较常见，如果一出错就让JVM崩溃这在工程上的代价比较大，所以出于健壮性考虑,JVM直接让崩溃的线程起死回生,并将错误或异常抛给用户进行处理。

### 动态设置需要注意的点？
在动态设置核心线程数时可能会出现设置无效的情况，这主要是由于在修改后，创建新的工作线程，工作线程在调用getTask方法获取任务时，会判断当前工作线程是否大于最大线程数，如果大于，就会执行减一操作并返回null，然后清理线程。这样一加一减就会导致设置无效。因此，我们再修改时应该同时修改最大线程数。

### 常见的内置线程池有哪些?
+ `FixedThreadPool`：它使用无界的LinkedBlockingQueue，因此最多只会创建corePoolSize个线程，因为队列是无界的，如果一时间堆积过多的任务请求的话可能会导致OOM。
+ `SingleThreadExecutor`：它是一个只有一个线程的线程池，它使用的也是无界的LinkedBlockingQueue，因此也会导致OOM。
+ `CachedThreadPool`：它是一个corePoolSize为0，maximumPoolSize为Integer.MAX_VALUE的线程池，所以他是无界的，也就意味着当线程的处理速度小于线程的提交速度时，有可能会导致cpu和内存资源耗尽。它使用的是同步队列SynchronousQueue
+ `ScheduledThreadPool`：它用来在一定的延迟之后运行任务或者定期执行任务，使用的是DelayedWorkQueue。

## Future
### Java异步的方式？
1. 线程异步：可以通过开子线程实现异步，配合线程池能够避免重复创建、销毁线程带来的开销
2. future、completablefuture：使用future类可以实现异步执行。completablefuture相比于future需要通过阻塞轮询来获得返回结果，completablefuture可以使用回调的方式来处理。
3. Springboot中的@async 注解（其实也是在线程池里面运行，但更加简洁）
+ <font style="color:rgb(51, 51, 51);">调用异步方法类上或者启动类加上注解 @EnableAsync</font>
+ <font style="color:rgb(51, 51, 51);">在需要被异步调用的方法外加上 @Async</font>
+ <font style="color:rgb(51, 51, 51);">所使用的 @Async 注解方法的类对象应该是Spring容器管理的bean对象；</font>

### 介绍一下Future类
Future类主要就是java中实现异步调用的一个类，它主要用在一些耗时较久的任务场景下，我们可以将耗时久的任务，利用Future类然他交给一个子线程去执行，主线程就可以去做别的事，然后再用Future类来获得执行结果，避免了程序一直在原地阻塞等待。

Future是一个泛型接口，在Java.util.concurrent包下，有五个方法，主要有四个作用：

1. 取消任务 cancel
2. 判断任务是否取消 isCanceled
3. 判断任务是否完成 isDone
4. 获得结果 get

### <font style="color:rgb(44, 62, 80);">Callable 和 Future 有什么关系？</font>
Future实现的是异步调用，我们需要获取子线程的执行结果，需要返回值，而Callable是一个具有返回值的接口，因此，使用Callable和FutureTask能够很好的实现异步调用。而FutureTask类实现了runnable接口和future接口，因此能够传入Thread的构造方法，创建线程。所以Callable结合FutureTask能够实现有返回的异步调用。

### Future的优缺点?
future的优点就是，配合线程池能够实现异步多线程任务配合，提高程序效率。future的缺点就是get方法获得返回结果要阻塞或轮询，且isDone方法轮询会导致CPU空转，不支持异步任务编排组合。

### <font style="color:rgb(44, 62, 80);">CompletableFuture 类有什么用？</font>
CompletableFuture能够解决future的一些缺点，比如获取结果需要阻塞或轮询，不支持异步任务编排等。它采用了一种类似观察者模式的机制，当异步任务执行完成之后会通知监听的一方。completableFuture实现类Future和comletionStage接口，能够支持函数式编程。当异步任务执行结束之后，可以通过回调方法whenComplete来进行处理。

同时，它提供了一些方法来进行多个异步任务的编排处理，比如thenRun，thenAccept，thenApply等。

### <font style="color:rgb(44, 62, 80);">CompletableFuture提供了哪些获取结果的方法？</font>
首先是两个get方法，一个可以传入超时时间，这两个也是future本来就有的方法，会阻塞等待。还提供了getNow和join方法，getNow方法会判断当前任务是否执行结束，如果结束则返回，没结束则返回设定的值，join方法类似于get，但它只会抛出运行时异常，而get方法抛出受检查异常。

### CompletableFuture怎么进行异步任务编排？它们有什么区别?
completablefuture提供了一些方法来进行异步任务编排，比如thenRun，thenAccept，thenApply，能够在异步任务执行完之后接着去执行其他异步任务。thenRun方法不需要上一个异步任务的返回值，而thenAccept则需要，且新任务不会产生返回值，thenApply方法类似于thenAccept，但新任务是有返回值的。

### 还有哪些常用方法？
runAsync初始化异步任务，无返回值

supplyAsync初始化异步任务，有返回值

handle方法对结果进行处理，包括异常

thenCombine合并两个异步任务的结果

applyToEither，两个异步方法，先完成的会触发该方法

## AQS
### 什么是AQS？介绍一下AQS
AQS就是AbstractQueueSynchronizer，是一个抽象队列同步器，它是一个抽象类，主要用来构建锁和同步器，它能够高效的构建出大量的同步器。像ReentrantLock、ReentrantReadWriteLock、同步队列等都是基于AQS的。AQS的核心思想就是，当一个线程访问共享资源时，如果共享资源没有被占用，那么就将该线程设置为有效工作线程，并对资源加锁进行访问。如果访问失败，则需要将线程添加到等待队列当中，AQS利用CLH队列来实现一整套的线程阻塞等待和唤醒时的锁分配机制。然后它利用一个volatile修饰的state变量来表示锁的状态，0则表示未锁定，大于0表示已锁定。

### 什么是CLH？
CLH是一个双向队列，AQS将请求资源的线程封装成CLH队列的一个节点，并存储在队列当中，一个节点中记录了该线程的引用，节点在当前队列中的状态，前驱节点和后继结点。它是按照一个先进先出的原则，来进行线程节点的入队和出队。

### 有哪些waitStatus？
一共有五种waitStatus：

1. 0，节点初始化的默认值
2. CANCELLED，值为1，代表该线程获取锁的请求已经被取消
3. SIGNAL，值为-1，表示后继线程需要被unpark，（表示该线程已经准备好，就等待锁释放）
4. CONDITION，值为-2，表示该节点线程还在等待唤醒
5. PROPAGATE，值为-3，在SHARED种才会被启用

### AQS的源码？具体的工作流程？
以ReentrantLock为例，当我们上锁的时候调用的是sync.lock()方法，该方法会根据当前是公平锁或非公平锁，进一步调用相应的lock方法，以非公平锁为例，在lock方法中，首先使用CAS操作尝试将state从0设置为1，如果成功则将当前线程设置为占有线程，失败的话就调用acquire方法。在acquire方法中，会调用tryAcquire再次去尝试获得锁，如果还是失败，则会调用addWaiter方法将该线程封装为node节点，并入队，然后调用acquireQueued方法，通过自旋的方式， 判断节点的状态，并进行相应处理，比如如果状态为0，则CAS修改为-1，如果状态为-1的话，则调用tryAcquire去抢锁。

释放锁时，调用的时unlock方法，对应sync的release方法，然后判断你是否为当前的占有线程，如果不是会抛出异常，是的话就将state-1，如果state==0，就释放锁，将占有线程置为null，并调用unparkSuccessor唤醒后续线程。

### AQS公平和非公平的区别？
AQS中，非公平和公平锁的区别主要在于tryAcquire方法中，非公平锁会直接使用CAS操作尝试将state从0改为1来获取锁，而公平锁则会先判断当前等待队列中是否有线程处于等待状态。

**<font style="color:rgb(51, 51, 51);">区别一：</font>**<font style="color:rgb(51, 51, 51);">非公平锁竞争锁资源会先去竞争锁，而公平锁只会在锁状态为0时才会竞争锁；</font>

**<font style="color:rgb(51, 51, 51);">区别二：</font>**<font style="color:rgb(51, 51, 51);">公平锁查看队列里面是否有节点，有的话，加入队列，没有的话直接去抢锁；而非公平锁则是直接抢锁。</font>

### <font style="color:rgb(44, 62, 80);">AQS 资源共享方式</font>
AQS有两种资源共享方式，一种是Exclusive独占式，一种是shared共享式，独占式就是只有一个线程能执行，如reentrantlock，共享式就是多个线程可同时执行，如信号量，countdown latch。

### 什么是semaphore？
semaphore是一个共享式的锁，能够运行多个线程同时访问资源，并且可以控制线程数量，我们可以在构造时传入permit参数，设置同时访问的线程数，相当于将AQS中的state设置为许可证数量。在调用acquire后，会判断当前state是否还足够分配给当前线程， 如果足够则CAS设置state-1，不足则会入队阻塞等待。

一些场景问题：

1. 令牌没有重入的概念，每次acquire都需要令牌
2. semaphore的令牌不以初始化为标准，<font style="color:#DF2A3F;">每次release都会增加一个令牌</font>

使用场景：

semaphore相当于普通独占锁的共享版本，用于限制获取资源的线程数量

例如n个银行窗口办理业务

### 什么是CountDownLatch？
countdown latch是一个共享锁，它将AQS的state设置为count，当调用countDown方法时，会执行CAS操作将state-1，直到state为0，当调用await方法时，如果state不为0，则线程会阻塞等待，当state为0时则会释放所有等待的线程。

使用场景：

countdownlatch可以用来实现等待多线程执行结束，如主线程等待组件的加载。

发令枪，阻塞线程，主线程执行coundown，让所有线程一起执行，例如秒杀

### 什么是CyclicBarrier
CyclicBarrier和countdown latch类似，能够实现线程间的技术等待。它能够让一组线程到达屏障时阻塞等待，此时会调用await方法执行parties-1，直到拦截住足够的线程，即parties=0时，才会让所有线程通过。它还可以在构造时传入一个runnable，让线程到达之后执行。而且它比起countdown latch，可以实现重复使用，因为<font style="color:#DF2A3F;">他会在释放线程时会重置parties</font>

使用场景：

循环版countdownlatch，可以拦截N个线程，再进入下一个执行步骤，如进入游戏，先等待所有玩家选完角色，第一次放行，然后再等待所有玩家加载完毕，第二次放行

## 并发集合
### 有哪些支持并发的集合?
+ ConcurrentHashMap：线程安全的hashmap
+ CopyOnWriteArrayList：线程安全的List，再读多写少的场景下性能很好。
+ ConcurrentrLinkedQueue：一个高效的并发队列，使用链表实现，且非阻塞
+ BlockingQueue：一个阻塞队列，是一个接口，可以通过链表、数组来实现。
+ ConcurrentSkipListMap：线程安全的Map，通过跳表实现，进行快速查找。

### ConcurrentHashMap和CopyOnWriteArrayList在集合部分
### 介绍一些ConcurrentLinkedQueue？
concurrentlinkedqueue是一个线程安全的非阻塞队列，它主要使用CAS操作来实现线程安全，底层是链表数据结构，它适合性能要求较高，同时有多个线程同时进行读写的场景。

### <font style="color:rgb(44, 62, 80);">说说ConcurrentLinkedQueue的HOPS(延迟更新的策略)的设计?</font>
concurrentLinkedQueue对tail和head的更新是延迟更新的，

在插入时，如果tail指向的下一个节点不为null，则会执行更新操作，找到真正的尾节点，并且完成插入操作之后才会cas更新tail，当tail指向的下一个节点为空时，直接插入节点，不更新。

在删除时，如果head指向的下一个节点的item域为null，则会定位到真正的头节点，并执行删除，然后cas更新head，如果不为null，则直接执行删除，不更新和head。

这样做的目的主要是，如果有大量的一个插入操作，那么每次都要cas更新tail，会损耗性能，因此doug lea设计了每间隔一个元素再去更新，降低了cas的次数，提升了性能。

### 介绍一下BlockingQueue？
BlockingQueue是一个阻塞队列，被广泛用在生产者消费者问题上，当队列满时，生产者线程会被阻塞，直到队列未满，当队列为空时，消费者线程会被阻塞，直到队列非空。BlockingQueue是一个接口，主要的实现类包括ArrayBlockingQueue、LinkedBlockingQueue、PriorityBlockingQueue。

### 分别介绍一下它的三个实现类？
+ ArrayBlockingQueue是一个有界阻塞队列，底层采用数组来实现，并发控制采用可重入锁reentrantlock。它一旦创建，容量不可改变，当队列满时，插入操作将阻塞，当队列为空时，取出操作将阻塞。它默认是非公平的方式，可以通过在构造时传入参数进行修改。
+ LinkedBlockingQueue是一个基于链表的阻塞队列，它可以是有界的也可以是无界的，它默认的队列长度是Integer.MAX_VALUE，因此，可能会导致容量过大，消耗内存，甚至OOM，因此在初始化时最好设置它的容量大小。它控制并发采用的是两把锁，一把putLock，一把takeLock。
+ DelayWorkQueue：是一个延迟队列，会对元素持有一段时间后，才允许元素被获取，适用于需要延时获取元素的场景。
+ SynchronousQueue：同步队列，只能容纳单个元素，当有额外的插入时会被阻塞。通常用于
+ PriorityBlockingQueue是一个优先级的无界阻塞队列，它可以通过自定义类实现compareTo方法或者传入构造参数Comparator来实现自定义排序，他底层采用reentrantlock来控制并发，且只能是无界队列。不能够村null

### <font style="color:rgb(44, 62, 80);">ConcurrentSkipListMap</font>

候选题（115）

候选 1新建

什么是线程和进程？二者有什么关系、区别及优缺点？

置信度 0.98

题目答案

分类标签

处理方式目标题目 ID

填写已有 canonical 题目 ID。当前正式题库 ID 也使用 q_ 前缀，不是临时占位。

候选 2新建

程序计数器为什么是线程私有的？

置信度 0.97

分类: Java 并发标签: 3

候选 3新建

虚拟机栈和本地方法栈为什么是线程私有的？

置信度 0.95

分类: Java 并发标签: 3

候选 4新建

并发与并行有什么区别？

置信度 0.99

分类: Java 并发标签: 3

候选 5新建

同步和异步有什么区别？

置信度 0.96

分类: Java 并发标签: 3

候选 6新建

为什么要使用多线程？

置信度 0.96

分类: Java 并发标签: 3

候选 7新建

Java 是怎么解决并发问题的？

置信度 0.95

分类: Java 并发标签: 4

候选 8新建

什么是守护线程？

置信度 0.94

分类: Java 并发标签: 3

候选 9新建

线程安全有哪些实现思路？

置信度 0.95

分类: Java 并发标签: 5

候选 10新建

使用多线程可能带来什么问题？

置信度 0.91

分类: Java 并发标签: 3

候选 11新建

线程的生命周期和状态有哪些？

置信度 0.97

分类: Java 并发标签: 3

候选 12新建

为什么 JVM 没有区分 READY 和 RUNNING 两种状态？

置信度 0.95

分类: Java 并发标签: 3

候选 13新建

什么是上下文切换？为什么频繁切换会影响性能？

置信度 0.96

分类: Java 并发标签: 3

候选 14新建

什么是线程死锁？产生死锁的四个必要条件是什么？

置信度 0.97

分类: Java 并发标签: 4

候选 15新建

如何预防和避免线程死锁？

置信度 0.94

分类: Java 并发标签: 4

候选 16新建

sleep() 和 wait() 有什么区别？

置信度 0.99

分类: Java 并发标签: 4

候选 17新建

为什么 wait() 方法不定义在 Thread 中？

置信度 0.97

分类: Java 并发标签: 4

候选 18新建

Thread.sleep()、Object.wait()、Condition.await()、LockSupport.park() 有什么区别？

置信度 0.90

分类: Java 并发标签: 4

候选 19新建

可以直接调用 Thread 的 run 方法吗？

置信度 0.98

分类: Java 并发标签: 3

候选 20新建

Runnable 和 Callable 有什么区别？

置信度 0.97

分类: Java 并发标签: 3

候选 21新建

什么是 volatile？它能保证什么，不能保证什么？

置信度 0.99

分类: Java 并发标签: 3

候选 22新建

volatile 有哪些应用场景？

置信度 0.89

分类: Java 并发标签: 3

候选 23新建

什么是指令重排序？为什么会发生？如何避免？

置信度 0.98

分类: Java 并发标签: 3

候选 24新建

什么是内存屏障？

置信度 0.96

分类: Java 并发标签: 3

候选 25新建

什么是 JMM？为什么需要 JMM？

置信度 0.99

分类: Java 并发标签: 3

候选 26新建

JMM 是如何抽象线程和主内存之间关系的？

置信度 0.94

分类: Java 并发标签: 3

候选 27新建

Java 内存区域和 JMM 有什么区别？

置信度 0.96

分类: Java 并发标签: 3

候选 28新建

什么是 happens-before 原则？

置信度 0.98

分类: Java 并发标签: 3

候选 29新建

happens-before 常见规则有哪些？

置信度 0.97

分类: Java 并发标签: 4

候选 30新建

什么是原子性、可见性和有序性？

置信度 0.92

分类: Java 并发标签: 4

候选 31新建

如何禁止指令重排序？

置信度 0.93

分类: Java 并发标签: 3

候选 32新建

volatile 如何保证可见性？

置信度 0.90

分类: Java 并发标签: 3

候选 33新建

volatile 可以保证原子性吗？

置信度 0.99

分类: Java 并发标签: 4

候选 34新建

什么是乐观锁和悲观锁？

置信度 0.97

分类: Java 并发标签: 4

候选 35新建

如何实现乐观锁？什么是版本号机制和 CAS？

置信度 0.97

分类: Java 并发标签: 4

候选 36新建

什么是原子操作？

置信度 0.95

分类: Java 并发标签: 3

候选 37新建

CAS 有哪些问题？

置信度 0.98

分类: Java 并发标签: 4

候选 38新建

synchronized 是什么？有什么用？

置信度 0.99

分类: Java 并发标签: 4

候选 39新建

什么是偏向锁？

置信度 0.94

分类: Java 并发标签: 4

候选 40新建

什么是轻量级锁？

置信度 0.91

分类: Java 并发标签: 4

候选 41新建

介绍一下 synchronized 锁膨胀过程。

置信度 0.84

分类: Java 并发标签: 4

候选 42新建

什么是适应性自旋锁？

置信度 0.93

分类: Java 并发标签: 4

候选 43新建

synchronized 的使用方式有哪些？锁的对象分别是什么？

置信度 0.98

分类: Java 并发标签: 4

候选 44新建

构造方法可以用 synchronized 修饰吗？

置信度 0.90

分类: Java 并发标签: 4

候选 45新建

synchronized 的底层原理是什么？

置信度 0.97

分类: Java 并发标签: 4

候选 46新建

JDK 1.6 之后 synchronized 做了哪些优化？

置信度 0.98

分类: Java 并发标签: 4

候选 47新建

synchronized 和 volatile 有什么区别？

置信度 0.99

分类: Java 并发标签: 4

候选 48新建

synchronized 有什么缺陷？

置信度 0.93

分类: Java 并发标签: 4

候选 49新建

Synchronized 使用时有哪些注意事项？

置信度 0.92

分类: Java 并发标签: 4

候选 50新建

什么是原子类？原子类是怎么实现的？有什么优势？

置信度 0.97

分类: Java 并发标签: 3

候选 51新建

AtomicStampedReference 和 AtomicMarkableReference 有什么区别？

置信度 0.95

分类: Java 并发标签: 3

候选 52新建

LongAdder 是什么？相比 AtomicLong 有什么优势？

置信度 0.90

分类: Java 并发标签: 3

候选 53新建

什么是 ReentrantLock？

置信度 0.98

分类: Java 并发标签: 4

候选 54新建

什么是可重入锁？

置信度 0.97

分类: Java 并发标签: 4

候选 55新建

公平锁和非公平锁有什么区别？

置信度 0.98

分类: Java 并发标签: 4

候选 56新建

synchronized 和 ReentrantLock 有什么区别？

置信度 0.99

分类: Java 并发标签: 4

候选 57新建

什么是 ReentrantReadWriteLock？适合什么场景？

置信度 0.98

分类: Java 并发标签: 4

候选 58新建

什么是读写锁、共享锁和独占锁？

置信度 0.96

分类: Java 并发标签: 4

候选 59新建

线程持有读锁还能获取写锁吗？

置信度 0.96

分类: Java 并发标签: 4

候选 60新建

读锁为什么不能升级为写锁？

置信度 0.97

分类: Java 并发标签: 4

候选 61新建

什么是 StampedLock？适合什么场景？

置信度 0.97

分类: Java 并发标签: 4

候选 62新建

为什么 StampedLock 是不可重入的？

置信度 0.92

分类: Java 并发标签: 4

候选 63新建

StampedLock 的性能为什么更好？

置信度 0.90

分类: Java 并发标签: 4

候选 64新建

StampedLock 的乐观读是如何执行的？

置信度 0.91

分类: Java 并发标签: 4

候选 65新建

什么是ThreadLocal？有什么用？

置信度 0.98

分类: Java 并发标签: 4

候选 66新建

ThreadLocal原理是什么？

置信度 0.97

分类: Java 并发标签: 4

候选 67新建

ThreadLocal内存泄漏是怎么导致的？

置信度 0.98

分类: Java 并发标签: 4

候选 68新建

ThreadLocal.set方法原理是什么？

置信度 0.94

分类: Java 并发标签: 4

候选 69新建

ThreadLocalMap如何清理过期key？

置信度 0.92

分类: Java 并发标签: 4

候选 70新建

ThreadLocalMap扩容机制是什么？

置信度 0.90

分类: Java 并发标签: 4

候选 71新建

ThreadLocal.get方法原理是什么？

置信度 0.91

分类: Java 并发标签: 4

候选 72新建

ThreadLocal有哪些注意事项？

置信度 0.96

分类: Java 并发标签: 4

候选 73新建

什么是InheritableThreadLocal？有什么用？

置信度 0.95

分类: Java 并发标签: 4

候选 74新建

ThreadLocal有哪些使用场景？

置信度 0.90

分类: Java 并发标签: 4

候选 75新建

什么是线程池？

置信度 0.98

分类: Java 并发标签: 3

候选 76新建

为什么要使用线程池？

置信度 0.98

分类: Java 并发标签: 3

候选 77新建

如何创建线程池？

置信度 0.95

分类: Java 并发标签: 3

候选 78新建

线程池如何维护运行状态？

置信度 0.92

分类: Java 并发标签: 3

候选 79新建

线程池如何实现线程管理？

置信度 0.93

分类: Java 并发标签: 4

候选 80新建

为什么Worker要设计成不可重入？

置信度 0.88

分类: Java 并发标签: 4

候选 81新建

线程池常见参数有哪些？

置信度 0.97

分类: Java 并发标签: 3

候选 82新建

为什么不推荐使用Executors内置线程池？

置信度 0.98

分类: Java 并发标签: 3

候选 83新建

线程池的keepAliveTime是怎么工作的？

置信度 0.95

分类: Java 并发标签: 3

候选 84新建

线程池的拒绝策略有哪些？

置信度 0.98

分类: Java 并发标签: 3

候选 85新建

线程池常用的阻塞队列有哪些？

置信度 0.93

分类: Java 并发标签: 3

候选 86新建

阻塞队列和普通队列有什么区别？如何实现阻塞？

置信度 0.95

分类: Java 并发标签: 4

候选 87新建

wait/notifyAll和Condition实现阻塞队列有什么区别？

置信度 0.90

分类: Java 并发标签: 4

候选 88新建

线程池有几种状态？

置信度 0.97

分类: Java 并发标签: 3

候选 89新建

线程池处理任务的流程是什么？

置信度 0.97

分类: Java 并发标签: 3

候选 90新建

如何设定线程池大小？

置信度 0.92

分类: Java 并发标签: 3

候选 91新建

如何动态修改线程池参数？

置信度 0.90

分类: Java 并发标签: 3

候选 92新建

线程池中线程抛出异常会怎么样？

置信度 0.95

分类: Java 并发标签: 3

候选 93新建

为什么线程崩溃了不会导致JVM崩溃？

置信度 0.82

分类: Java 并发标签: 3

候选 94新建

常见的内置线程池有哪些？

置信度 0.95

分类: Java 并发标签: 3

候选 95新建

Java有哪些异步实现方式？

置信度 0.90

分类: Java 并发标签: 3

候选 96新建

介绍一下Future类

置信度 0.95

分类: Java 并发标签: 3

候选 97新建

Callable和Future有什么关系？

置信度 0.96

分类: Java 并发标签: 3

候选 98新建

Future的优缺点是什么？

置信度 0.94

分类: Java 并发标签: 3

候选 99新建

CompletableFuture有什么用？

置信度 0.96

分类: Java 并发标签: 3

候选 100新建

CompletableFuture有哪些获取结果的方法？

置信度 0.94

分类: Java 并发标签: 3

候选 101新建

CompletableFuture怎么进行异步任务编排？它们有什么区别？

置信度 0.96

分类: Java 并发标签: 3

候选 102新建

什么是AQS？请介绍一下AQS。

置信度 0.98

分类: Java 并发标签: 4

候选 103新建

什么是CLH队列？

置信度 0.94

分类: Java 并发标签: 4

候选 104新建

AQS有哪些waitStatus状态？

置信度 0.97

分类: Java 并发标签: 4

候选 105新建

AQS的工作流程是怎样的？以ReentrantLock为例说明。

置信度 0.95

分类: Java 并发标签: 4

候选 106新建

AQS公平锁和非公平锁有什么区别？

置信度 0.95

分类: Java 并发标签: 4

候选 107新建

AQS有哪些资源共享方式？

置信度 0.93

分类: Java 并发标签: 4

候选 108新建

什么是Semaphore？

置信度 0.96

分类: Java 并发标签: 4

候选 109新建

什么是CountDownLatch？

置信度 0.95

分类: Java 并发标签: 3

候选 110新建

什么是CyclicBarrier？

置信度 0.94

分类: Java 并发标签: 3

候选 111新建

有哪些支持并发的集合？

置信度 0.92

分类: Java 并发标签: 3

候选 112新建

介绍一下ConcurrentLinkedQueue。

置信度 0.92

分类: Java 并发标签: 3

候选 113新建

说说ConcurrentLinkedQueue的HOPS延迟更新策略。

置信度 0.91

分类: Java 并发标签: 3

候选 114新建

介绍一下BlockingQueue。

置信度 0.95

分类: Java 并发标签: 3

候选 115新建

分别介绍一下BlockingQueue的常见实现类。

置信度 0.92

分类: Java 并发标签: 4

导入预览

新建预览

什么是线程和进程？二者有什么关系、区别及优缺点？

分类: Java 并发

标签: Java, 并发, Java 并发

答案预览

进程是程序的一次执行过程，是系统运行程序的基本单位，程序的执行对应着一个进程的创建、运行和销毁。在Java中，启动main函数就是启动了一个JVM进程，而main函数所在线程称为主线程。 而线程是一个比进程更小的执行单位，一个进程下可以有多个线程，多个线程之间共享进程的一些资源，如堆、方法区，同时各个线程也有一些自己的私有资源，如程序计数器、虚拟机栈、本地方法栈等。且在线程之间切换的开销要比进程小得多。 线程是一个比进程更小的执行单位，一个进程下可以有多个线程，多个线程之间共享进程的一些资源，如堆、方法区，同时各个线程也有一些自己的私有资源，如程序计数器、虚拟机栈、本地方法栈等。相比进程，各个进程之间相互独立，而线程则不一定。线程执行开销小，但不利于资源的管理和保护，而进程则相反。

批量摘要

新建

115

合并

跳过

解析提示

Long source was parsed in 3 chunks because raw_text exceeded 24000 characters.
Chunk 1/3: 该来源为知识笔记而非真实面经，未包含公司、岗位、轮次等面试元数据。
Chunk 1/3: 内容为长文档分块中的第1块，仅能提取本块明确出现的问题；部分主题如银行家算法、锁消除、锁粗化、内存屏障如何保证一致性仅出现标题或残缺提示，未单独提取。
Chunk 1/3: 个别原文表述可能存在术语不严谨或笔误，如 TIME_WAITING 应为 TIMED_WAITING、LongAddr/longaddr 应为 LongAdder、CLH 被写为 CHL、部分原子性/有序性描述混淆；canonical_answer 已尽量按本块可支持内容做规范化。
Chunk 2/3: 该文本为长文档分块中的第2块，仅能提取本块明确出现的内容。
Chunk 2/3: 开头关于StampedLock读锁的内容主要为图片OCR流程图，缺少足够文字说明，未稳定提炼为问答。
Chunk 2/3: 部分表述可能存在术语或细节不严谨之处，例如对ThreadLocal弱引用“用来解决内存泄漏问题”等说法，已尽量按原文归纳。
Chunk 3/3: 该分块为文档末尾片段，只能基于当前内容提取，部分上下文可能缺失。
Chunk 3/3: 个别表述存在口语化或不严谨之处，如SynchronousQueue相关描述未写完整，DelayWorkQueue是否作为BlockingQueue常见实现类的表述需谨慎。
Chunk 3/3: 文末仅出现“ConcurrentSkipListMap”标题，未提供展开内容，因此未单独提炼对应问答。

这个任务已经确认过了，不会再次写入 canonical。

返回队列

创建时间: 2026/03/28 17:54

开始时间: 2026/03/28 21:05

完成时间: 2026/03/28 21:25