Java synchronized 关键字详解：从入门到原理

在这里插入图片描述

适用对象

本课程适合具备 Java 基础语法知识，初步了解多线程概念但尚未系统学习并发编程的开发者。无论你是准备面试的求职者，还是希望提升并发编程能力的工程师，这门课程都将为你打下坚实基础。

学习目标

通过两个课时的系统学习，你将能够：

掌握 synchronized 的三种使用方式及其区别
理解 synchronized 解决线程安全问题的核心原理
剖析 synchronized 底层的 Monitor 机制和锁升级过程
区分 synchronized 与 volatile、ReentrantLock 的适用场景
应对面试中关于 synchronized 的高频问题

课程安排

第一课时（约 40 分钟）：基础概念、使用方式、特性详解
第二课时（约 50 分钟）：底层原理、锁升级机制、对比与实战

第一课时：synchronized 基础与使用

1.1 从一个线程安全问题开始

让我们先看一个经典问题：两个线程同时对共享变量执行自增操作。

public class Counter {
    private int count = 0;

    public void increment() {
        count++;// 不是原子操作！
    }

    public int getCount() {
        return count;
    }
}

// 测试代码
public class Test {
    public static void main(String[] args) throws InterruptedException {
        Counter counter = new Counter();
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) counter.increment();
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10000; i++) counter.increment();
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
        System.out.println("最终结果：" + counter.getCount());// 期望 20000，实际小于 20000
    }
}

运行结果：多次执行，结果总是小于 20000，有时甚至相差甚远。

问题根源：count++看似一行代码，但在 JVM 中分解为三条指令：

从主内存读取 count 到工作内存（读）
对 count 进行加 1 操作（改）
将结果写回主内存（写）

当两个线程同时执行这三步时，可能发生交替执行，导致最后写入的值覆盖了之前的计算结果——这就是典型的竞态条件。

1.2 synchronized 是什么？

synchronized 是 Java 提供的一个关键字，译为'同步'。它可以保证在同一时刻，最多只有一个线程执行被它修饰的代码段，从而解决并发环境下的线程安全问题。

从专业角度说，synchronized 实现了互斥访问，它保证了三个关键特性：

特性	说明
原子性	被保护的代码块要么全部执行，要么完全不执行，不会被打断
可见性	一个线程修改共享变量后，其他线程能立即看到最新值
有序性	禁止编译器和处理器对同步块内的代码进行指令重排序

1.3 初识 synchronized 的三种用法

synchronized 的使用非常灵活，可以根据需要选择不同的加锁对象。下面我们通过三个典型场景来理解它们的区别。

1.3.1 修饰实例方法

public class SyncMethodDemo {
    private int count = 0;

    // synchronized 修饰实例方法，锁是当前对象 this
    public synchronized void increment() {
        count++;
    }
}

特点：

锁对象是调用该方法的实例对象（即 this）
同一个对象的多个 synchronized 实例方法，共用同一把锁
不同对象的方法互不干扰

示意图：

线程 A ──> obj1.increment() ──> 获取 obj1 锁 ──> 执行 
线程 B ──> obj1.increment() ──> 等待 obj1 锁 
线程 C ──> obj2.increment() ──> 获取 obj2 锁 ──> 执行（与 A 不冲突）

1.3.2 修饰静态方法

public class SyncStaticDemo {
    private static int count = 0;

    // synchronized 修饰静态方法，锁是当前类的 Class 对象
    public static synchronized void increment() {
        count++;
    }
}

特点：

锁对象是当前类的Class 对象（如 SyncStaticDemo.class）
所有实例对象共享同一把类锁
静态方法锁与实例方法锁互不干扰

思考题：如果一个类既有 synchronized 静态方法，又有 synchronized 实例方法，两个线程分别调用它们，会互斥吗？

答案：不会。因为一个是类锁，一个是对象锁，两把不同的锁。

1.3.3 修饰代码块

public class SyncBlockDemo {
    private Object lock = new Object();
    private int count = 0;

    public void increment() {
        // 同步代码块，锁是指定的 lock 对象
        synchronized (lock) {
            count++;
        }
    }

    public void decrement() {
        // 也可以锁 this
        synchronized (this) {
            count--;
        }
    }
}

特点：

锁对象可以任意指定，灵活性最高
可以精确控制同步范围，提高并发性能
常用锁对象：this、自定义锁对象、类.class

1.4 深入理解锁的范围

1.4.1 三种锁的对比表格

使用形式	锁对象	作用范围	典型应用场景
修饰实例方法	当前实例对象	单个实例内	保护实例变量
修饰静态方法	当前类的 Class 对象	所有实例间	保护静态变量
修饰代码块	指定的任意对象	代码块内	细粒度控制

1.4.2 常见面试题解析

问题 1：synchronized 修饰代码块可以给类加锁吗？
当然可以！只要在括号内传入 类名.class 即可。例如：

synchronized (SyncBlockDemo.class) {
    // 这是类锁
}

问题 2：构造方法可以用 synchronized 修饰吗？
不可以！Java 语法规定构造方法不能是同步的。实际上，构造方法本身就是线程安全的，因为 JVM 会保证在对象初始化完成前，其他线程无法访问该对象。

问题 3：静态同步方法和非静态同步方法同时调用会互斥吗？
不会互斥。假设线程 A 调用实例对象的非静态同步方法，线程 B 同时调用该对象所属类的静态同步方法，它们持有的是两把不同的锁（对象锁 vs 类锁），因此可以并行执行。

1.5 synchronized 的核心特性

1.5.1 可重入性

概念：同一个线程在持有锁的情况下，可以再次获取同一把锁，而不会被阻塞。

public class ReentrantDemo {
    public synchronized void methodA() {
        System.out.println("进入 methodA");
        methodB();// 直接调用，不会死锁
    }

    public synchronized void methodB() {
        System.out.println("进入 methodB");
    }
}

为什么需要可重入？
如果没有可重入性，线程在调用 methodA 获取锁后，调用 methodB 时发现自己还要申请同一把锁，就会形成死锁。这显然不合理。

实现原理：每个锁关联一个持有线程和一个计数器。线程第一次获取锁时，计数器置为 1；同一线程再次获取时，计数器递增；释放一次，计数器递减。直到计数器归零，锁才真正释放。

1.5.2 可见性保证

synchronized 不仅能保证原子性，还能保证内存可见性。JMM（Java 内存模型）规定：

线程释放锁时，会将工作内存中的共享变量刷新到主内存
线程获取锁时，会清空工作内存，从主内存重新读取共享变量

这就确保了：一个线程修改的共享变量，在释放锁后，其他线程能立即看到最新值。

1.6 第一课时小结

synchronized 是 Java 内置的同步关键字，解决原子性、可见性、有序性问题
三种使用方式：实例方法（锁 this）、静态方法（锁 Class 对象）、代码块（锁任意对象）
核心特性：可重入性、可见性、互斥性
不同锁对象决定了不同的同步范围

第二课时：synchronized 原理与优化

2.1 从字节码看 synchronized 的本质

2.1.1 同步代码块的字节码

先看一段简单的同步代码块：

public class SyncCodeBlock {
    public void doSomething() {
        synchronized (this) {
            System.out.println("hello");
        }
    }
}

使用 javap -c -v 反编译后，关键字节码如下：

 3: monitorenter // 进入同步块，获取监视器锁 
 4: getstatic // 调用 System.out 
 7: ldc // 加载字符串 
 9: invokevirtual // 调用 println 
 12: aload_1 
 13: monitorexit // 退出同步块，释放监视器锁 
 14: goto 22 // 正常结束跳转 
 17: astore_2 // 异常处理开始 
 18: aload_1 
 19: monitorexit // 异常时也释放锁 
 20: aload_2 
 21: athrow // 抛出异常 
 22: return

关键发现：

同步代码块使用 monitorenter 和 monitorexit 指令
有两个 monitorexit：一个正常退出，一个异常退出，确保锁一定被释放
这就是为什么 synchronized 即使抛出异常也不会死锁

2.1.2 同步方法的字节码

public synchronized void syncMethod() {
    System.out.println("hello");
}

反编译结果：

public synchronized void syncMethod(); descriptor: ()V flags: ACC_PUBLIC, ACC_SYNCHRONIZED // 注意这个标志 
Code:
    0: getstatic #2 
    3: ldc #3 
    5: invokevirtual #4 
    8: return

同步方法没有 monitorenter/monitorexit 指令，而是通过方法表 flags 中的 ACC_SYNCHRONIZED 标识。JVM 根据这个标识判断是否需要获取锁。

结论：两种实现方式本质上都是获取对象的监视器锁（Monitor Lock），只是表现形式不同。

2.2 Monitor 机制深度剖析

2.2.1 什么是 Monitor？

Monitor（监视器）是操作系统中用于实现线程同步的机制。Java 中的每个对象都与一个 Monitor 关联，这个关联关系存储在对象头的 Mark Word 中。

可以把 Monitor 理解为一个'接待室'，里面有三个关键区域：

┌─────────────────────┐
│ Owner │ ← 当前持有锁的线程
├─────────────────────┤
│ EntryList │ ← 等待获取锁的线程队列
├─────────────────────┤
│ WaitSet │ ← 调用了 wait() 的线程队列
└─────────────────────┘

2.2.2 Monitor 的核心数据结构

在 HotSpot 虚拟机中，Monitor 由 C++ 的 ObjectMonitor 类实现，关键字段如下：

字段	作用
`_owner`	指向当前持有锁的线程
`_EntryList`	等待获取锁的线程队列
`_WaitSet`	调用了 wait() 的线程队列
`_recursions`	记录锁的重入次数
`_count`	记录线程获取锁的次数

2.2.3 锁获取和释放的完整流程

以两个线程 T0 和 T1 竞争锁为例：

步骤 1：线程 T0 尝试获取锁

根据对象头找到对应的 ObjectMonitor
检查 _owner 是否为 null
通过 CAS 操作将 _owner 设为 T0，_count 设为 1
T0 获取锁成功，进入同步块执行

步骤 2：线程 T1 尝试获取锁

此时 _owner 为 T0，T1 CAS 失败
T1 会先自旋几次尝试（适应性自旋）
如果 T0 很快释放锁，T1 就成功获取
如果 T0 未释放，T1 进入 _EntryList 阻塞等待

步骤 3：T0 释放锁

执行 monitorexit，_count 减 1
若 _count 变为 0，_owner 设为 null
唤醒 _EntryList 中的线程（通常是队首线程）
T1 被唤醒，重新竞争锁

2.3 锁升级：从偏向锁到重量级锁

早期 Java 的 synchronized 性能较差，被称为'重量级锁'。JDK 1.6 之后引入了一系列优化，让 synchronized 的性能大幅提升。这就是著名的锁升级机制。

2.3.1 为什么需要锁升级？

想象一下这些场景：

场景 A：只有一个线程访问同步代码，根本不需要锁竞争
场景 B：两个线程交替访问，几乎没有同时竞争
场景 C：多个线程激烈竞争，需要操作系统级别的锁

如果用重量级锁统一处理所有场景，场景 A 和 B 会造成不必要的性能开销。锁升级就是让 synchronized 能够根据竞争激烈程度，动态调整锁的'重量'。

2.3.2 锁的四种状态

从低到高，锁有四种状态：

无锁状态
偏向锁
轻量级锁
重量级锁

锁可以升级，但不能降级（除了一次 GC 清理）。

2.3.3 偏向锁（Biased Locking）

适用场景：只有一个线程反复获取同一把锁。

原理：

第一次获取锁时，通过 CAS 将线程 ID 记录到对象头
之后该线程再来时，只需检查对象头中是否是自己 ID
如果是，直接进入，无需任何同步操作

示例代码：

public class BiasedLockDemo {
    private static List<Integer> list = new Vector<>(); // Vector 的方法都是同步的

    public static void main(String[] args) {
        for (int i = 0; i < 100; i++) {
            list.add(i); // 同一线程反复获取锁
        }
    }
}

优点：几乎没有加锁开销，性能极高。
缺点：一旦有其他线程尝试竞争，偏向锁立即撤销并升级。

注意：从 JDK 15 开始，偏向锁被标记为废弃，未来可能移除。因为在实际应用中，它的性能提升有限，且维护成本高。

2.3.4 轻量级锁（Lightweight Locking）

适用场景：两个线程交替执行同步块，没有真正的竞争。

原理：

线程在自己的栈帧中创建 Lock Record，存储对象头的拷贝
通过 CAS 尝试将对象头指向 Lock Record
如果成功，获取轻量级锁
如果失败，说明有竞争，升级为重量级锁

轻量级锁的解锁：

通过 CAS 将对象头恢复为原 Mark Word
如果恢复成功，解锁完成
如果失败，说明已经升级为重量级锁，走重量级锁解锁流程

2.3.5 重量级锁（Heavyweight Locking）

适用场景：多个线程激烈竞争。

原理：

线程进入 _EntryList 队列阻塞
依赖操作系统 Mutex Lock 实现
涉及用户态和内核态切换，开销较大

2.3.6 锁升级流程总结

偏向锁
│
│ 有其他线程尝试获取
↓
轻量级锁
│
│ 有真实竞争
↓
重量级锁

2.4 synchronized 与 volatile 的对比

特性	synchronized	volatile
原子性	✅ 保证	❌ 不保证
可见性	✅ 保证	✅ 保证
有序性	✅ 保证	✅ 保证（禁止重排序）
用法	修饰方法或代码块	修饰变量
性能	较重（但有优化）	极轻
适用场景	复合操作	单一变量状态标志

volatile 适用示例：

public class VolatileDemo {
    private volatile boolean flag = true; // 只作为状态标志

    public void stop() {
        flag = false; // 简单写操作
    }

    public void run() {
        while (flag) { // 执行任务
        }
    }
}

2.5 synchronized 与 ReentrantLock 的对比

2.5.1 对比表格

对比维度	synchronized	ReentrantLock
实现方式	JVM 关键字	Java API（基于 AQS）
锁释放	自动释放	必须手动 unlock
公平性	非公平	可设置公平/非公平
可中断	不支持	支持 lockInterruptibly()
超时获取	不支持	支持 tryLock(timeout)
尝试获取	不支持	支持 tryLock()
条件变量	一个等待集	多个 Condition
锁状态查询	不支持	支持查询持有线程等

2.5.2 如何选择？

优先使用 synchronized的情况：

同步逻辑简单，不需要高级功能
希望代码简洁不易出错
JVM 持续优化，性能已很好

选择 ReentrantLock的情况：

需要公平锁
需要尝试获取锁或超时获取
需要可中断的锁获取
需要多个条件变量（如生产者 - 消费者模式）
高竞争场景需要更精细控制

2.5.3 ReentrantLock 使用示例

ReentrantLock lock = new ReentrantLock(true); // 公平锁
Condition notFull = lock.newCondition();
Condition notEmpty = lock.newCondition();

// 标准使用模式
lock.lock();
try {
    // 临界区代码
    while (条件不满足) {
        notEmpty.await(); // 等待
    }
    // 执行操作
    notFull.signal();
} finally {
    lock.unlock(); // 必须释放
}

2.6 实战：线程安全的单例模式

综合运用 synchronized，实现几种经典的单例模式。

2.6.1 饿汉式（线程安全）

public class EagerSingleton {
    private static final EagerSingleton INSTANCE = new EagerSingleton();

    private EagerSingleton() {}

    public static EagerSingleton getInstance() {
        return INSTANCE;
    }
}

2.6.2 懒汉式（同步方法版）

public class LazySingleton {
    private static LazySingleton instance;

    private LazySingleton() {}

    public static synchronized LazySingleton getInstance() {
        if (instance == null) {
            instance = new LazySingleton();
        }
        return instance;
    }
}

2.6.3 双重检查锁（DCL）

public class DCLSingleton {
    // volatile 保证可见性和禁止重排序
    private static volatile DCLSingleton instance;

    private DCLSingleton() {}

    public static DCLSingleton getInstance() {
        if (instance == null) {
            synchronized (DCLSingleton.class) {
                if (instance == null) {
                    instance = new DCLSingleton();
                }
            }
        }
        return instance;
    }
}

为什么需要 volatile？
instance = new DCLSingleton()不是原子操作，可能发生指令重排序。如果不加 volatile，其他线程可能拿到一个未初始化完成的对象。这是 DCL 的关键细节。

2.7 第二课时小结

synchronized 底层基于 Monitor 实现，字节码层面使用 monitorenter/monitorexit 或 ACC_SYNCHRONIZED
锁升级机制（偏向锁→轻量级锁→重量级锁）大幅提升了性能
synchronized 保证原子性、可见性、有序性，是全面的同步工具
与 volatile 相比，synchronized 更重量但功能更全
与 ReentrantLock 相比，synchronized 简单易用，ReentrantLock 功能更丰富
实际开发中，根据场景选择合适的同步机制

课程总结

通过两个课时的学习，我们全面掌握了 synchronized 关键字：

第一课时：从线程安全问题出发，学习了 synchronized 的三种使用方式、锁的范围、可重入性等基础概念
第二课时：深入底层，剖析了 Monitor 机制、锁升级流程，并对比了 volatile 和 ReentrantLock

synchronized 作为 Java 最基础的同步工具，虽然简单，但背后的原理并不简单。理解它的实现机制，不仅能帮助我们写出更正确的并发程序，还能在面试中脱颖而出。

课后思考题

如果一个线程在同步块中抛出异常，锁会自动释放吗？为什么？
偏向锁在 JDK 15 中被废弃的原因是什么？谈谈你的理解。
如何用 synchronized 实现一个阻塞队列？
为什么说 synchronized 是'悲观锁'，而 CAS 是'乐观锁'？