Java synchronized 是内置锁，用于解决多线程共享资源安全问题。支持修饰实例方法、静态方法和代码块三种用法，分别锁定 this、Class 对象和指定对象。核心特性包括原子性、可见性、有序性、可重入性和非公平性。底层基于 JVM Monitor 锁和对象头 Mark Word 实现，JDK 1.6 后引入锁升级机制（无锁、偏向锁、轻量级锁、重量级锁）优化性能。详细解析其用法、原理及常见面试题。
synchronized 是 Java 中的内置锁（也叫监视器锁 Monitor Lock），是一种非公平、可重入的独占锁。它可以修饰方法、代码块，通过'锁定特定对象'的方式，让多个线程排队访问共享资源，从而保证同一时刻只有一个线程能执行被锁定的代码，解决线程安全问题。
我们先看一个没有使用 synchronized 的例子，直观感受线程不安全的问题：模拟多线程执行'自增操作'（共享变量 count 从 0 自增到 10000）。
「预期结果」：10000 + 10000 = 20000 「实际结果」：大概率是小于 20000 的随机数（比如 18937、19562）
「原因」：count++ 不是原子操作，当两个线程同时读取到同一个 count 值（比如 100），线程 1 自增为 101、线程 2 自增也为 101，最终写入内存的是 101，相当于'少加了一次'。这种多线程竞争共享资源导致的数据错乱，就是'线程不安全'，而 synchronized 就能解决这个问题。
我们给 increment 方法加上 synchronized 修饰，再执行代码：
public class SynchronizedDemo {
// 共享变量
private static int count = 0;
// 自增方法（未加锁）
public static void increment() {
count++; // 看似一行代码，实际是 读取 count → 自增 → 写入 count 三步操作（非原子）
}
public static void main(String[] args) throws InterruptedException {
// 线程 1：执行 10000 次自增
Thread thread1 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
increment();
}
});
// 线程 2：执行 10000 次自增
Thread thread2 = new Thread(() -> {
for (int i = 0; i < 10000; i++) {
increment();
}
});
thread1.start();
thread2.start();
thread1.join(); // 等待线程 1 执行完毕
thread2.join(); // 等待线程 2 执行完毕
System.out.println("最终 count 值：" + count);
}
}
「实际结果」：每次执行都是 20000，完全符合预期。
「原理」：synchronized 锁定了 increment 方法，让多个线程排队执行该方法，同一时刻只有一个线程能进入方法执行 count++，保证了自增操作的原子性，从而避免了数据错乱。
synchronized 有三种核心用法，分别是「修饰实例方法」、「修饰静态方法」、「修饰代码块」，每种用法锁定的'对象'不同，适用场景也不同，必须区分清楚（面试常考）。
synchronized 修饰非静态方法（实例方法）时，锁定的是「调用该方法的对象实例」（this）。也就是说，同一个对象实例调用该方法时，会排队执行；不同对象实例调用该方法时，互不影响（因为锁定的是不同的对象）。
public class SynchronizedInstanceMethod {
// 实例变量（属于对象实例的共享资源）
private int num = 0;
// synchronized 修饰实例方法，锁定 this（当前对象）
public synchronized void add() {
for (int i = 0; i < 1000; i++) {
num++;
}
}
public static void main(String[] args) throws InterruptedException {
// 创建两个不同的对象实例
SynchronizedInstanceMethod obj1 = new SynchronizedInstanceMethod();
SynchronizedInstanceMethod obj2 = new SynchronizedInstanceMethod();
// 线程 1：调用 obj1 的 add 方法
Thread t1 = new Thread(obj1::add);
// 线程 2：调用 obj2 的 add 方法
Thread t2 = new Thread(obj2::add);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("obj1.num：" + obj1.num); // 1000（预期）
System.out.println("obj2.num：" + obj2.num); // 1000（预期）
}
}
「说明」：t1 锁定的是 obj1，t2 锁定的是 obj2，两个线程锁定的是不同对象，因此可以同时执行 add 方法，互不干扰，最终两个对象的 num 都能达到 1000。
「注意」：如果两个线程调用的是同一个对象实例的 add 方法，就会排队执行，比如将 t2 改为 new Thread(obj1::add)，那么最终 obj1.num 会是 2000。
synchronized 修饰静态方法时，锁定的不是 this，而是「当前类的 Class 对象」（每个类在 JVM 中只有一个 Class 对象，全局唯一）。因此，无论创建多少个对象实例，调用该静态方法时，所有线程都会排队执行（因为锁定的是同一个 Class 对象）。
public class SynchronizedStaticMethod {
// 静态变量（属于类的共享资源，全局唯一）
private static int num = 0;
// synchronized 修饰静态方法，锁定 SynchronizedStaticMethod.class
public static synchronized void add() {
for (int i = 0; i < 1000; i++) {
num++;
}
}
public static void main(String[] args) throws InterruptedException {
SynchronizedStaticMethod obj1 = new SynchronizedStaticMethod();
SynchronizedStaticMethod obj2 = new SynchronizedStaticMethod();
// 线程 1：调用 obj1 的静态 add 方法
Thread t1 = new Thread(obj1::add);
// 线程 2：调用 obj2 的静态 add 方法
Thread t2 = new Thread(obj2::add);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("num：" + num); // 2000（预期）
}
}
「说明」：虽然 t1 和 t2 调用的是不同对象实例的 add 方法，但 add 是静态方法，锁定的是 SynchronizedStaticMethod.class（全局唯一），因此两个线程会排队执行 add 方法，最终 num 累加为 2000。
synchronized 修饰代码块时，需要手动指定「锁定的对象」（括号内填写锁定对象），语法：synchronized(锁定对象) { 需同步的代码 }。这种用法的灵活度最高，可以只锁定'需要同步的代码片段'（而非整个方法），减少锁的粒度，提升程序性能。
常见的锁定对象有两种：this（当前对象）、Class 对象，也可以是自定义的对象（只要保证多线程锁定的是同一个对象即可）。
public class SynchronizedBlockThis {
private int num = 0;
public void add() {
// 只锁定自增相关的代码块，而非整个 add 方法
synchronized (this) {
for (int i = 0; i < 1000; i++) {
num++;
}
}
// 非同步代码（多个线程可同时执行）
System.out.println("非同步代码执行");
}
public static void main(String[] args) throws InterruptedException {
SynchronizedBlockThis obj = new SynchronizedBlockThis();
Thread t1 = new Thread(obj::add);
Thread t2 = new Thread(obj::add);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("num：" + obj.num); // 2000（预期）
}
}
「说明」：只有 synchronized 代码块内的自增操作会被同步，代码块外的打印语句可以被多个线程同时执行，相比修饰整个实例方法，减少了锁的范围，提升了效率。
public class SynchronizedBlockClass {
private static int num = 0;
public void add() {
// 锁定 Class 对象，全局唯一
synchronized (SynchronizedBlockClass.class) {
for (int i = 0; i < 1000; i++) {
num++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynchronizedBlockClass obj1 = new SynchronizedBlockClass();
SynchronizedBlockClass obj2 = new SynchronizedBlockClass();
Thread t1 = new Thread(obj1::add);
Thread t2 = new Thread(obj2::add);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("num：" + num); // 2000（预期）
}
}
public class SynchronizedBlockCustom {
private int num = 0;
// 自定义锁定对象（必须保证多线程使用的是同一个对象）
private final Object lock = new Object();
public void add() {
// 锁定自定义对象 lock
synchronized (lock) {
for (int i = 0; i < 1000; i++) {
num++;
}
}
}
public static void main(String[] args) throws InterruptedException {
SynchronizedBlockCustom obj = new SynchronizedBlockCustom();
Thread t1 = new Thread(obj::add);
Thread t2 = new Thread(obj::add);
t1.start();
t2.start();
t1.join();
t2.join();
System.out.println("num：" + obj.num); // 2000（预期）
}
}
「注意」：自定义锁定对象建议用 final 修饰，避免对象被修改（如果 lock 被重新赋值，会导致多个线程锁定不同对象，失去同步效果）。
| 用法 | 锁定对象 | 同步范围 | 适用场景 |
|---|---|---|---|
| 修饰实例方法 | this（当前对象实例） | 整个实例方法 | 实例变量的同步（多个线程操作同一个对象的实例变量） |
| 修饰静态方法 | 当前类的 Class 对象 | 整个静态方法 | 静态变量的同步（多个线程操作同一个类的静态变量） |
| 修饰代码块 | 手动指定（this、Class、自定义对象） | 代码块内的代码 | 灵活控制同步粒度（只同步需要的代码，提升效率） |
synchronized 能保证线程安全，核心依赖于它的三个特性：原子性、可见性、有序性，除此之外，它还是「可重入锁」、「非公平锁」，这些特性是面试的核心考点，必须逐一搞懂。
「原子性」：指一个操作或多个操作，要么全部执行完成，要么全部不执行，中间不会被其他线程打断。就像'银行转账'，从 A 账户扣钱、给 B 账户加钱，这两个操作必须同时完成，不能只执行一半。
synchronized 能保证「被锁定的代码块/方法」的原子性：同一时刻只有一个线程能进入被锁定的代码，避免了多线程同时执行导致的操作中断，从而保证了原子性。
「补充」：Java 中还有一些原子类（如 AtomicInteger），也能保证原子性，但底层是 CAS 机制，和 synchronized 的实现方式不同。
「可见性」：指当一个线程修改了共享变量的值后，其他线程能立即看到这个修改后的值。
为什么会有'不可见性'？因为每个线程都有自己的「工作内存」，线程读取共享变量时，会先从主内存中拷贝一份到工作内存，后续操作都基于工作内存中的副本；当线程修改了共享变量后，会先更新工作内存中的副本，再异步刷新到主内存中。如果其他线程此时读取共享变量，可能读取的还是主内存中未被更新的值，导致数据错乱。
synchronized 能保证可见性：当线程释放锁时，会将工作内存中修改后的共享变量值「强制刷新到主内存」；当线程获取锁时，会「清空工作内存中的共享变量副本」，重新从主内存中读取最新的值。这样就保证了多个线程看到的共享变量值是一致的。
「有序性」：指程序执行的顺序按照代码的先后顺序执行。但在 JVM 中，为了提升性能，会对代码进行「指令重排序」（在不影响单线程执行结果的前提下，调整指令的执行顺序）。
指令重排序在单线程环境下没问题，但在多线程环境下，可能会导致程序执行结果异常。例如：
// 共享变量
private static int a = 0;
private static boolean flag = false;
// 线程 1 执行
public static void thread1() {
a = 1; // 指令 1
flag = true; // 指令 2
}
// 线程 2 执行
public static void thread2() {
if (flag) { // 指令 3
System.out.println(a); // 可能输出 0，而非 1
}
}
「原因」：JVM 可能会将线程 1 的指令 1 和指令 2 重排序（因为单线程下，先执行 flag=true 再执行 a=1，结果不变），如果线程 1 先执行 flag=true，线程 2 此时读取 flag 为 true，就会打印 a 的值（此时 a 还未被赋值为 1，还是 0），导致结果异常。
synchronized 能保证有序性：被 synchronized 锁定的代码块，会禁止指令重排序，保证代码按照编写顺序执行。同时，synchronized 还能保证'happens-before'关系，进一步保证多线程环境下的有序性。
「可重入性」：指一个线程已经获取了某个锁，当它再次需要获取该锁时（比如递归调用被锁定的方法），可以直接获取，不会导致死锁。
synchronized 是可重入锁，我们用递归案例验证：
public class SynchronizedReentrant {
// 锁定 this
public synchronized void methodA() {
System.out.println("进入 methodA");
methodB(); // 递归调用 methodB（同样锁定 this）
}
// 同样锁定 this
public synchronized void methodB() {
System.out.println("进入 methodB");
}
public static void main(String[] args) {
SynchronizedReentrant obj = new SynchronizedReentrant();
obj.methodA(); // 正常执行，不会死锁
}
}
「执行结果」：
进入 methodA 进入 methodB
「说明」：线程调用 methodA 时，获取了 this 锁；在 methodA 中调用 methodB 时，因为 methodB 锁定的也是 this 锁，而线程已经持有该锁，所以可以直接进入 methodB，不会死锁。这就是可重入性的体现。
「补充」：synchronized 的可重入性，底层是通过「锁计数器」实现的：线程第一次获取锁时，计数器置为 1；再次获取该锁时，计数器加 1；释放锁时，计数器减 1；当计数器为 0 时，锁才会被真正释放，其他线程才能获取。
「公平锁」：多个线程等待同一个锁时，按照'先到先得'的顺序获取锁，不会出现线程饥饿（某个线程一直得不到锁）。
「非公平锁」：多个线程等待同一个锁时，线程获取锁的顺序是随机的，不一定是先到先得，可能存在某个线程多次获取锁，而其他线程长期等待的情况。
synchronized 是「非公平锁」：当锁被释放时，等待队列中的线程不会按照排队顺序获取锁，而是随机竞争，这样做的目的是「提升程序性能」（避免了线程排队的开销）。
「补充」：Java 中的 ReentrantLock 可以实现公平锁和非公平锁（默认非公平），后续会对比 synchronized 和 ReentrantLock 的区别。
前面我们讲了 synchronized 的用法和特性，接下来拆解最核心的底层原理 —— 它到底是靠什么实现'锁定对象、保证线程安全'的？
synchronized 的底层实现依赖于 JVM 的「监视器锁（Monitor）」，而 Monitor 的实现又和「对象头」、「字节码指令」密切相关。我们从'字节码层面'和'JVM 层面'两个维度拆解。
我们先看一段简单的代码，反编译它的字节码，看看 synchronized 在字节码层面是如何表现的。
public class SynchronizedBytecode {
private final Object lock = new Object();
public void test() {
synchronized (lock) {
System.out.println("synchronized 代码块");
}
}
}
使用 javac 编译后，再用 javap -v 反编译，查看 test 方法的字节码（核心部分）：
public void test(); descriptor: ()V flags: ACC_PUBLIC Code: stack=2, locals=3, args_size=1
0: aload_0
1: getfield #2 // Field lock:Ljava/lang/Object;
4: dup
5: astore_1
6: monitorenter // 进入同步代码块，获取锁
7: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
10: ldc #4 // String synchronized 代码块
12: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/String;)V
15: aload_1
16: monitorexit // 退出同步代码块，释放锁
17: goto 25
20: astore_2
21: aload_1
22: monitorexit // 异常情况下释放锁
23: aload_2
24: athrow
25: return
「核心指令解析」：
「注意」：字节码中会有两个 monitorexit 指令，第一个用于正常退出同步代码块时释放锁，第二个用于异常情况下释放锁（避免锁泄露）。
「补充」：如果是 synchronized 修饰方法（实例方法/静态方法），字节码层面不会出现 monitorenter 和 monitorexit 指令，而是会在方法的访问标志中增加 ACC_SYNCHRONIZED 标志，JVM 会根据该标志自动为方法添加 Monitor 的获取和释放逻辑（本质和代码块一致）。
前面提到，synchronized 锁定的是'对象'，而 Monitor 锁是和'对象'绑定的 —— 每个 Java 对象在 JVM 中都有一个「对象头」，对象头中包含了「Monitor 锁的相关信息」，这也是 synchronized 能锁定对象的核心原因。
Java 对象头由两部分组成（32 位 JVM 为例）：
其中，Mark Word 的结构会随着「锁状态」的变化而变化，synchronized 的锁升级机制也和 Mark Word 密切相关。Mark Word 的默认结构（无锁状态）如下：
| 位偏移 | 内容 | 说明 |
|---|---|---|
| 0-1 位 | 锁状态标志 | 01：无锁状态；00：轻量级锁；10：重量级锁；11：偏向锁 |
| 2 位 | 是否偏向锁 | 0：无偏向；1：偏向锁 |
| 3-23 位 | 对象的哈希码 | 无锁/偏向锁状态下存储 |
| 24-30 位 | 对象的分代年龄 | GC 回收时使用 |
| 31 位 | 无意义（固定为 0） | - |
Monitor 是 JVM 内部的一个数据结构，也叫「监视器」，每个对象都有一个对应的 Monitor（可以理解为'锁的载体'）。Monitor 的结构如下（简化版）：
「Monitor 工作流程」：
在 JDK 1.6 之前，synchronized 是「重量级锁」—— 每次获取和释放锁都需要调用操作系统的互斥量（Mutex），切换线程状态（用户态 ↔ 内核态），开销很大，效率很低。
为了优化 synchronized 的性能，JDK 1.6 及以后引入了「锁升级机制」：synchronized 的锁会从「无锁」→「偏向锁」→「轻量级锁」→「重量级锁」逐步升级，根据线程竞争的激烈程度动态调整，减少锁的开销。
锁升级的核心依据：「线程竞争的激烈程度」—— 竞争越激烈，锁的级别越高，开销也越大，但能保证线程安全。
「场景」：没有线程竞争共享资源，对象处于无锁状态。
「Mark Word 特征」：锁状态标志为 01，是否偏向锁为 0，存储对象的哈希码和分代年龄。
「场景」：只有一个线程多次获取同一个锁，没有其他线程竞争。
「核心思想」：既然只有一个线程获取锁，就不需要每次都执行 monitorenter/monitorexit 指令（避免内核态切换），而是将锁'偏向'于这个线程，后续该线程再次获取锁时，直接通过 Mark Word 验证即可，无需竞争。
「升级过程」：
「补充」：偏向锁是 JDK 1.6 默认开启的，可通过 JVM 参数 -XX:-UseBiasedLocking 关闭。
「场景」：有多个线程竞争同一个锁，但竞争不激烈（线程交替获取锁，没有长时间阻塞）。
「核心思想」：当偏向锁被打破（有其他线程竞争），锁升级为轻量级锁，此时线程获取锁时，不再使用 Monitor（避免内核态切换），而是通过「CAS 机制」竞争锁。
「升级过程」：
「补充」：自旋锁的目的是避免线程阻塞（内核态切换开销大），适合竞争不激烈的场景；如果竞争激烈，自旋会浪费 CPU 资源，此时升级为重量级锁更合适。
「场景」：多个线程激烈竞争同一个锁，自旋多次仍无法获取锁。
「核心思想」：重量级锁依赖于 JVM 中的 Monitor 和操作系统的互斥量（Mutex），线程获取不到锁时，会进入阻塞状态（放弃 CPU 资源），直到锁被释放后被唤醒。
「Mark Word 特征」：锁状态标志为 10，存储指向 Monitor 的指针，此时线程获取锁会触发内核态切换，开销最大。
| 锁状态 | 适用场景 | 实现方式 | 开销 |
|---|---|---|---|
| 无锁 | 无线程竞争 | 无锁机制 | 无 |
| 偏向锁 | 单线程重复获取锁 | Mark Word 存储线程 ID | 极低 |
| 轻量级锁 | 多线程交替竞争，竞争不激烈 | CAS 机制 + 自旋 | 较低 |
| 重量级锁 | 多线程激烈竞争 | Monitor + 操作系统互斥量 | 较高 |
结合前面的内容，整理了 synchronized 最常考的面试题，每个问题都给出简洁、精准的答案（适合面试时直接回答）。
答：保证多线程环境下共享资源的原子性、可见性和有序性，避免数据错乱，实现线程安全。
答：三种用法：
答：非公平锁。当锁被释放时，等待队列中的线程不会按照排队顺序获取锁，而是随机竞争，目的是提升程序性能。
答：是可重入锁。可重入性指一个线程已经获取了某个锁，当它再次需要获取该锁时（如递归调用），可以直接获取，不会导致死锁。底层通过锁计数器实现。
答：
答：引入了「锁升级机制」，从无锁 → 偏向锁 → 轻量级锁 → 重量级锁逐步升级，根据线程竞争激烈程度动态调整锁的级别，减少锁的开销；同时引入了自旋锁、偏向锁等优化，提升了 synchronized 的性能。
答：核心区别：volatile 只能保证可见性和有序性，不能保证原子性；synchronized 能保证原子性、可见性和有序性。
| 特性 | synchronized | volatile |
|---|---|---|
| 原子性 | 支持 | 不支持 |
| 可见性 | 支持 | 支持 |
| 有序性 | 支持 | 支持（禁止指令重排序） |
| 锁机制 | 独占锁（可重入、非公平） | 无锁机制 |
答：
synchronized 是 Java 并发编程的基础，也是面试必考的知识点，从入门到底层，核心要点可以总结为：
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
查找任何按下的键的javascript键代码、代码、位置和修饰符。 在线工具，Keycode 信息在线工具，online
JavaScript 字符串转义/反转义；Java 风格 \uXXXX（Native2Ascii）编码与解码。 在线工具，Escape 与 Native 编解码在线工具，online
使用 Prettier 在浏览器内格式化 JavaScript 或 HTML 片段。 在线工具，JavaScript / HTML 格式化在线工具，online
Terser 压缩、变量名混淆，或 javascript-obfuscator 高强度混淆（体积会增大）。 在线工具，JavaScript 压缩与混淆在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online