Java八股文面试[完整版]——2025
Synchronized底层原理摘要： 基本机制：通过对象锁实现互斥访问，同一时刻仅一个线程能持有锁 核心实现：基于JVM提供的Monitor监视器（C++实现），包含Owner、EntryList、WaitSet三个关键区域 锁升级：JDK1.6引入偏向锁（单线程重入优化）、轻量级锁（交替访问CAS优化）、重量级锁（Monitor实现） 内存结构：对象头中的MarkWord记录锁状态（无锁001
讲一下synchronized关键字的底层原理？
难易程度：☆☆☆☆☆
出现频率：☆☆☆
1.1 基本使用
如下抢票的代码，如果不加锁，就会出现超卖或者一张票卖给多个人
Synchronized【对象锁】采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】，其它线程再想获取这个【对象锁】时就会阻塞住。
-
public class TicketDemo { -
static Object lock = new Object(); -
int ticketNum = 10; -
public synchronized void getTicket() { -
synchronized (this) { -
if (ticketNum <= 0) { -
return; -
} -
System.out.println(Thread.currentThread().getName() + "抢到一张票,剩余:" + ticketNum); -
// 非原子性操作 -
ticketNum--; -
} -
} -
public static void main(String[] args) { -
TicketDemo ticketDemo = new TicketDemo(); -
for (int i = 0; i < 20; i++) { -
new Thread(() -> { -
ticketDemo.getTicket(); -
}).start(); -
} -
} -
}
AI运行代码
1.2 Monitor
Monitor 被翻译为监视器，是由jvm提供，c++语言实现
在代码中想要体现monitor需要借助javap命令查看clsss的字节码，比如以下代码：
-
public class SyncTest { -
static final Object lock = new Object(); -
static int counter = 0; -
public static void main(String[] args) { -
synchronized (lock) { -
counter++; -
} -
} -
}
AI运行代码
找到这个类的class文件，在class文件目录下执行javap -v SyncTest.class，反编译效果如下：
- monitorenter 上锁开始的地方
- monitorexit 解锁的地方
- 其中被monitorenter和monitorexit包围住的指令就是上锁的代码
- 有两个monitorexit的原因，第二个monitorexit是为了防止锁住的代码抛异常后不能及时释放锁
在使用了synchornized代码块时需要指定一个对象，所以synchornized也被称为对象锁
monitor主要就是跟这个对象产生关联，如下图
Monitor内部具体的存储结构：
-
Owner：存储当前获取锁的线程的，只能有一个线程可以获取
-
EntryList：关联没有抢到锁的线程，处于Blocked状态的线程
-
WaitSet：关联调用了wait方法的线程，处于Waiting状态的线程
具体的流程：
- 代码进入synchorized代码块，先让lock（对象锁）关联的monitor，然后判断Owner是否有线程持有
- 如果没有线程持有，则让当前线程持有，表示该线程获取锁成功
- 如果有线程持有，则让当前线程进入entryList进行阻塞，如果Owner持有的线程已经释放了锁，在EntryList中的线程去竞争锁的持有权（非公平）
- 如果代码块中调用了wait()方法，则会进去WaitSet中进行等待
参考回答：
-
Synchronized【对象锁】采用互斥的方式让同一时刻至多只有一个线程能持有【对象锁】
-
它的底层由monitor实现的，monitor是jvm级别的对象（ C++实现），线程获得锁需要使用对象（锁）关联monitor
-
在monitor内部有三个属性，分别是owner、entrylist、waitset
-
其中owner是关联的获得锁的线程，并且只能关联一个线程；entrylist关联的是处于阻塞状态的线程；waitset关联的是处于Waiting状态的线程
synchronized关键字的底层原理-进阶
Monitor实现的锁属于重量级锁，你了解过锁升级吗？
-
Monitor实现的锁属于重量级锁，里面涉及到了用户态和内核态的切换、进程的上下文切换，成本较高，性能比较低。
-
在JDK 1.6引入了两种新型锁机制：偏向锁和轻量级锁，它们的引入是为了解决在没有多线程竞争或基本没有竞争的场景下因使用传统锁机制带来的性能开销问题。
篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc
需要全套面试笔记及答案【点击此处即可/免费获取】
https://docs.qq.com/doc/DQXdYWE9LZ2ZHZ1ho
2.1 对象的内存结构
在HotSpot虚拟机中，对象在内存中存储的布局可分为3块区域：对象头（Header）、实例数据（Instance Data）和对齐填充
我们需要重点分析MarkWord对象头
2.2 MarkWord
hashcode：25位的对象标识Hash码
age：对象分代年龄占4位
biased_lock：偏向锁标识，占1位 ，0表示没有开始偏向锁，1表示开启了偏向锁
thread：持有偏向锁的线程ID，占23位
epoch：偏向时间戳，占2位
ptr_to_lock_record：轻量级锁状态下，指向栈中锁记录的指针，占30位
ptr_to_heavyweight_monitor：重量级锁状态下，指向对象监视器Monitor的指针，占30位
我们可以通过lock的标识，来判断是哪一种锁的等级
- 后三位是001表示无锁
- 后三位是101表示偏向锁
- 后两位是00表示轻量级锁
- 后两位是10表示重量级锁
2.3 再说Monitor重量级锁
每个 Java 对象都可以关联一个 Monitor 对象，如果使用 synchronized 给对象上锁（重量级）之后，该对象头的Mark Word 中就被设置指向 Monitor 对象的指针
简单说就是：每个对象的对象头都可以设置monoitor的指针，让对象与monitor产生关联
2.4 轻量级锁
在很多的情况下，在Java程序运行时，同步块中的代码都是不存在竞争的，不同的线程交替的执行同步块中的代码。这种情况下，用重量级锁是没必要的。因此JVM引入了轻量级锁的概念。
-
static final Object obj = new Object(); -
public static void method1() { -
synchronized (obj) { -
// 同步块 A -
method2(); -
} -
} -
public static void method2() { -
synchronized (obj) { -
// 同步块 B -
} -
}
AI运行代码
加锁的流程
1.在线程栈中创建一个Lock Record，将其obj字段指向锁对象。
2.通过CAS指令将Lock Record的地址存储在对象头的mark word中（数据进行交换），如果对象处于无锁状态则修改成功，代表该线程获得了轻量级锁。
3.如果是当前线程已经持有该锁了，代表这是一次锁重入。设置Lock Record第一部分为null，起到了一个重入计数器的作用。
4.如果CAS修改失败，说明发生了竞争，需要膨胀为重量级锁。
解锁过程
1.遍历线程栈,找到所有obj字段等于当前锁对象的Lock Record。
2.如果Lock Record的Mark Word为null，代表这是一次重入，将obj设置为null后continue。
3.如果Lock Record的 Mark Word不为null，则利用CAS指令将对象头的mark word恢复成为无锁状态。如果失败则膨胀为重量级锁。
2.5 偏向锁
轻量级锁在没有竞争时（就自己这个线程），每次重入仍然需要执行 CAS 操作。
Java 6 中引入了偏向锁来做进一步优化：只有第一次使用 CAS 将线程 ID 设置到对象的 Mark Word 头，之后发现
这个线程 ID 是自己的就表示没有竞争，不用重新 CAS。以后只要不发生竞争，这个对象就归该线程所有
-
static final Object obj = new Object(); -
public static void m1() { -
synchronized (obj) { -
// 同步块 A -
m2(); -
} -
} -
public static void m2() { -
synchronized (obj) { -
// 同步块 B -
m3(); -
} -
} -
public static void m3() { -
synchronized (obj) { -
} -
}
AI运行代码
加锁的流程
1.在线程栈中创建一个Lock Record，将其obj字段指向锁对象。
2.通过CAS指令将Lock Record的线程id存储在对象头的mark word中，同时也设置偏向锁的标识为101，如果对象处于无锁状态则修改成功，代表该线程获得了偏向锁。
3.如果是当前线程已经持有该锁了，代表这是一次锁重入。设置Lock Record第一部分为null，起到了一个重入计数器的作用。与轻量级锁不同的时，这里不会再次进行cas操作，只是判断对象头中的线程id是否是自己，因为缺少了cas操作，性能相对轻量级锁更好一些
解锁流程参考轻量级锁
2.6 参考回答
Java中的synchronized有偏向锁、轻量级锁、重量级锁三种形式，分别对应了锁只被一个线程持有、不同线程交替持有锁、多线程竞争锁三种情况。
| 描述 | |
|---|---|
| 重量级锁 | 底层使用的Monitor实现，里面涉及到了用户态和内核态的切换、进程的上下文切换，成本较高，性能比较低。 |
| 轻量级锁 | 线程加锁的时间是错开的（也就是没有竞争），可以使用轻量级锁来优化。轻量级修改了对象头的锁标志，相对重量级锁性能提升很多。每次修改都是CAS操作，保证原子性 |
| 偏向锁 | 一段很长的时间内都只被一个线程使用锁，可以使用了偏向锁，在第一次获得锁时，会有一个CAS操作，之后该线程再获取锁，只需要判断mark word中是否是自己的线程id即可，而不是开销相对较大的CAS命令 |
一旦锁发生了竞争，都会升级为重量级锁
你谈谈 JMM（Java 内存模型）
难易程度：☆☆☆
出现频率：☆☆☆
JMM(Java Memory Model)Java内存模型,是java虚拟机规范中所定义的一种内存模型。
Java内存模型(Java Memory Model)描述了Java程序中各种变量(线程共享变量)的访问规则，以及在JVM中将变量存储到内存和从内存中读取变量这样的底层细节。
特点：
-
所有的共享变量都存储于主内存(计算机的RAM)这里所说的变量指的是实例变量和类变量。不包含局部变量，因为局部变量是线程私有的，因此不存在竞争问题。
-
每一个线程还存在自己的工作内存，线程的工作内存，保留了被线程使用的变量的工作副本。
-
线程对变量的所有的操作(读，写)都必须在工作内存中完成，而不能直接读写主内存中的变量，不同线程之间也不能直接访问对方工作内存中的变量，线程间变量的值的传递需要通过主内存完成。
CAS 你知道吗？
难易程度：☆☆☆
出现频率：☆☆
篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafc
需要全套面试笔记及答案【点击此处即可/免费获取】
4.1 概述及基本工作流程
CAS的全称是： Compare And Swap(比较再交换)，它体现的一种乐观锁的思想，在无锁情况下保证线程操作共享数据的原子性。
在JUC（ java.util.concurrent ）包下实现的很多类都用到了CAS操作
-
AbstractQueuedSynchronizer（AQS框架）
-
AtomicXXX类
例子：
- 线程1与线程2都从主内存中获取变量int a = 100,同时放到各个线程的工作内存中
一个当前内存值V、旧的预期值A、即将更新的值B，当且仅当旧的预期值A和内存值V相同时，将内存值修改为B并返回true，否则什么都不做，并返回false。如果CAS操作失败，通过自旋的方式等待并再次尝试，直到成功
-
线程1操作：V：int a = 100，A：int a = 100，B：修改后的值：int a = 101 (a++)
- 线程1拿A的值与主内存V的值进行比较，判断是否相等
- 如果相等，则把B的值101更新到主内存中
-
线程2操作：V：int a = 100，A：int a = 100，B：修改后的值：int a = 99(a–)
- 线程2拿A的值与主内存V的值进行比较，判断是否相等(目前不相等，因为线程1已更新V的值99)
- 不相等，则线程2更新失败
-
自旋锁操作
-
因为没有加锁，所以线程不会陷入阻塞，效率较高
-
如果竞争激烈，重试频繁发生，效率会受影响
-
需要不断尝试获取共享内存V中最新的值，然后再在新的值的基础上进行更新操作，如果失败就继续尝试获取新的值，直到更新成功
4.2 CAS 底层实现
CAS 底层依赖于一个 Unsafe 类来直接调用操作系统底层的 CAS 指令
都是native修饰的方法，由系统提供的接口执行，并非java代码实现，一般的思路也都是自旋锁实现。
在java中比较常见使用有很多，比如ReentrantLock和Atomic开头的线程安全类，都调用了Unsafe中的方法
- ReentrantLock中的一段CAS代码
4.3 乐观锁和悲观锁
-
CAS 是基于乐观锁的思想：最乐观的估计，不怕别的线程来修改共享变量，就算改了也没关系，我吃亏点再重试呗。
-
synchronized 是基于悲观锁的思想：最悲观的估计，得防着其它线程来修改共享变量，我上了锁你们都别想改，我改完了解开锁，你们才有机会。
请谈谈你对 volatile 的理解
难易程度：☆☆☆
出现频率：☆☆☆
一旦一个共享变量（类的成员变量、类的静态成员变量）被volatile修饰之后，那么就具备了两层语义：
5.1 保证线程间的可见性
保证了不同线程对这个变量进行操作时的可见性，即一个线程修改了某个变量的值，这新值对其他线程来说是立即可见的,volatile关键字会强制将修改的值立即写入主存。
一个典型的例子：永不停止的循环
-
package com.itheima.basic; -
// 可见性例子 -
// -Xint -
public class ForeverLoop { -
static boolean stop = false; -
public static void main(String[] args) { -
new Thread(() -> { -
try { -
Thread.sleep(100); -
} catch (InterruptedException e) { -
e.printStackTrace(); -
} -
stop = true; -
System.out.println("modify stop to true..."); -
}).start(); -
foo(); -
} -
static void foo() { -
int i = 0; -
while (!stop) { -
i++; -
} -
System.out.println("stopped... c:"+ i); -
} -
}
AI运行代码
当执行上述代码的时候，发现foo()方法中的循环是结束不了的，也就说读取不到共享变量的值结束循环。
主要是因为在JVM虚拟机中有一个JIT（即时编辑器）给代码做了优化。
上述代码
while (!stop) {
i++;
}AI运行代码
在很短的时间内，这个代码执行的次数太多了，当达到了一个阈值，JIT就会优化此代码，如下：
while (true) {
i++;
}AI运行代码
当把代码优化成这样子以后，及时
stop变量改变为了false也依然停止不了循环
解决方案：
第一：
在程序运行的时候加入vm参数-Xint表示禁用即时编辑器，不推荐，得不偿失（其他程序还要使用）
第二：
在修饰stop变量的时候加上volatile,表示当前代码禁用了即时编辑器，问题就可以解决，代码如下：
static volatile boolean stop = false;
AI运行代码
- 1
5.2 禁止进行指令重排序
用 volatile 修饰共享变量会在读、写共享变量时加入不同的屏障，阻止其他读写操作越过屏障，从而达到阻止重排序的效果
在去获取上面的结果的时候，有可能会出现4种情况
情况一：先执行actor2获取结果—>0,0(正常)
情况二：先执行actor1中的第一行代码，然后执行actor2获取结果—>0,1(正常)
情况三：先执行actor1中所有代码，然后执行actor2获取结果—>1,1(正常)
情况四：先执行actor1中第二行代码，然后执行actor2获取结果—>1,0(发生了指令重排序，影响结果)
解决方案
在变量上添加volatile，禁止指令重排序，则可以解决问题
屏障添加的示意图
- 写操作加的屏障是阻止上方其它写操作越过屏障排到volatile变量写之下
- 读操作加的屏障是阻止下方其它读操作越过屏障排到volatile变量读之上
其他补充
我们上面的解决方案是把volatile加在了int y这个变量上，我们能不能把它加在int x这个变量上呢？
下面代码使用volatile修饰了x变量
屏障添加的示意图
这样显然是不行的，主要是因为下面两个原则：
- 写操作加的屏障是阻止上方其它写操作越过屏障排到volatile变量写之下
- 读操作加的屏障是阻止下方其它读操作越过屏障排到volatile变量读之上
所以，现在我们就可以总结一个volatile使用的小妙招：
- 写变量让volatile修饰的变量的在代码最后位置
- 读变量让volatile修饰的变量的在代码最开始位置
什么是AQS？
难易程度：☆☆☆
出现频率：☆☆☆
6.1 概述
全称是 AbstractQueuedSynchronizer，是阻塞式锁和相关的同步器工具的框架，它是构建锁或者其他同步组件的基础框架
AQS与Synchronized的区别
| synchronized | AQS |
|---|---|
| 关键字，c++ 语言实现 | java 语言实现 |
| 悲观锁，自动释放锁 | 悲观锁，手动开启和关闭 |
| 锁竞争激烈都是重量级锁，性能差 | 锁竞争激烈的情况下，提供了多种解决方案 |
AQS常见的实现类
-
ReentrantLock 阻塞式锁
-
Semaphore 信号量
-
CountDownLatch 倒计时锁
篇幅限制下面就只能给大家展示小册部分内容了。整理了一份核心面试笔记包括了：Java面试、Spring、JVM、MyBatis、Redis、MySQL、并发编程、微服务、Linux、Springboot、SpringCloud、MQ、Kafka 面试专题
需要全套面试笔记【点击此处即可】免费获取
6.2 工作机制
- 在AQS中维护了一个使用了volatile修饰的state属性来表示资源的状态，0表示无锁，1表示有锁
- 提供了基于 FIFO 的等待队列，类似于 Monitor 的 EntryList
- 条件变量来实现等待、唤醒机制，支持多个条件变量，类似于 Monitor 的 WaitSet
- 线程0来了以后，去尝试修改state属性，如果发现state属性是0，就修改state状态为1，表示线程0抢锁成功
- 线程1和线程2也会先尝试修改state属性，发现state的值已经是1了，有其他线程持有锁，它们都会到FIFO队列中进行等待，
- FIFO是一个双向队列，head属性表示头结点，tail表示尾结点
如果多个线程共同去抢这个资源是如何保证原子性的呢？
在去修改state状态的时候，使用的cas自旋锁来保证原子性，确保只能有一个线程修改成功，修改失败的线程将会进入FIFO队列中等待
AQS是公平锁吗，还是非公平锁？
-
新的线程与队列中的线程共同来抢资源，是非公平锁
-
新的线程到队列中等待，只让队列中的head线程获取锁，是公平锁
比较典型的AQS实现类ReentrantLock，它默认就是非公平锁，新的线程与队列中的线程共同来抢资源
ReentrantLock的实现原理
难易程度：☆☆☆☆
出现频率：☆☆☆
7.1 概述
ReentrantLock翻译过来是可重入锁，相对于synchronized它具备以下特点：
-
可中断
-
可以设置超时时间
-
可以设置公平锁
-
支持多个条件变量
-
与synchronized一样，都支持重入
7.2 实现原理
ReentrantLock主要利用CAS+AQS队列来实现。它支持公平锁和非公平锁，两者的实现类似
构造方法接受一个可选的公平参数（默认非公平锁），当设置为true时，表示公平锁，否则为非公平锁。公平锁的效率往往没有非公平锁的效率高，在许多线程访问的情况下，公平锁表现出较低的吞吐量。
查看ReentrantLock源码中的构造方法：
提供了两个构造方法，不带参数的默认为非公平
如果使用带参数的构造函数，并且传的值为true，则是公平锁
其中NonfairSync和FairSync这两个类父类都是Sync
而Sync的父类是AQS，所以可以得出ReentrantLock底层主要实现就是基于AQS来实现的
工作流程
-
线程来抢锁后使用cas的方式修改state状态，修改状态成功为1，则让exclusiveOwnerThread属性指向当前线程，获取锁成功
-
假如修改状态失败，则会进入双向队列中等待，head指向双向队列头部，tail指向双向队列尾部
-
当exclusiveOwnerThread为null的时候，则会唤醒在双向队列中等待的线程
-
公平锁则体现在按照先后顺序获取锁，非公平体现在不在排队的线程也可以抢锁
synchronized和Lock有什么区别 ?
难易程度：☆☆☆☆
出现频率：☆☆☆☆
参考回答
- 语法层面
- synchronized 是关键字，源码在 jvm 中，用 c++ 语言实现
- Lock 是接口，源码由 jdk 提供，用 java 语言实现
- 使用 synchronized 时，退出同步代码块锁会自动释放，而使用 Lock 时，需要手动调用 unlock 方法释放锁
- 功能层面
- 二者均属于悲观锁、都具备基本的互斥、同步、锁重入功能
- Lock 提供了许多 synchronized 不具备的功能，例如获取等待状态、公平锁、可打断、可超时、多条件变量
- Lock 有适合不同场景的实现，如 ReentrantLock， ReentrantReadWriteLock
有“AI”的1024 = 2048，欢迎大家加入2048 AI社区
更多推荐
13
0- 0
已为社区贡献17条内容
所有评论(0)