java synchronized关键字用法和底层原理
一、synchronized的用法
synchronized关键字用于实现线程同步，确保多个线程在访问共享资源时不会发生数据竞争和不一致的问题。它主要有三种使用方式：
1. 同步实例方法
publicsynchronizedvoidmethod(){// 同步代码}- 锁对象是当前实例（
this）。 - 同一个实例的多个线程调用此方法时会互斥。
2. 同步静态方法
publicstaticsynchronizedvoidstaticMethod(){// 同步代码}- 锁对象是当前类的 Class 对象（如
MyClass.class）。 - 所有实例的线程调用此方法时都会互斥。
3. 同步代码块
synchronized(lockObject){// 同步代码}- 可以灵活指定锁对象（可以是任意对象）。
- 缩小了同步范围，提高性能。
4. 深入：wait(),notify(),notifyAll()
这三个方法是定义在Object类中的本地方法，必须在一个同步代码块或同步方法内（即已经持有该对象的监视器锁）调用，否则会抛出IllegalMonitorStateException异常。它们与synchronized配合使用，实现线程间的协调（等待/通知机制）。
wait(): 使当前线程释放其持有的对象锁，并进入等待状态（WAITING），直到其他线程调用该对象的notify()或notifyAll()方法，或被中断。调用后，线程会释放锁。notify(): 随机唤醒一个正在等待该对象锁的线程。被唤醒的线程会从等待池移动到阻塞队列（EntryList）中，等待锁释放后重新竞争锁。notifyAll(): 唤醒所有正在等待该对象锁的线程。这些线程都会被移动到阻塞队列中，共同竞争锁。
典型的生产者-消费者模式示例：
publicclassWaitNotifyExample{privatefinalObjectlock=newObject();privatebooleanconditionMet=false;publicvoidconsumer()throwsInterruptedException{synchronized(lock){// 使用while循环防止"虚假唤醒"while(!conditionMet){lock.wait();// 释放lock锁，当前线程进入等待}// 条件满足，执行消费任务System.out.println("Consuming...");conditionMet=false;lock.notifyAll();// 消费完成，通知生产者}}publicvoidproducer()throwsInterruptedException{synchronized(lock){while(conditionMet){lock.wait();// 如果条件已满足，则等待消费者消费}// 生产任务System.out.println("Producing...");conditionMet=true;lock.notifyAll();// 生产完成，通知消费者}}}关键点：
- 总是需要在循环中调用
wait()以防止虚假唤醒（Spurious Wakeup），即线程可能在没有被通知、中断或超时的情况下醒来。 wait()会释放锁，而sleep()不会。- 通常更推荐使用
notifyAll()，因为notify()是随机唤醒，可能导致某些线程永远无法被唤醒（线程饥饿）。
二、底层原理
synchronized的底层实现依赖于 JVM 内部的监视器锁（Monitor）机制，主要涉及以下概念：
1. 对象头与 Mark Word
- 在 HotSpot 虚拟机中，每个对象都有一个对象头，其中包含Mark Word（标记字段）。
- Mark Word 的长度为 32位 或 64位，用于存储对象的哈希码、分代年龄、锁状态标志位等信息。锁的状态就记录在这里。
2. 锁升级的详细过程
为了平衡性能与安全性，JVM 对synchronized进行了优化，引入了锁升级机制。这个过程是单向的：无锁 → 偏向锁 → 轻量级锁 → 重量级锁。
无锁状态 (01)
- 初始状态，对象刚被创建，尚未有任何线程竞争。
偏向锁 (Biased Locking) (01)
- 目的：消除在无竞争情况下的同步开销。假设在大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得。
- 流程：
- 加锁：当一个线程第一次访问同步块时，它会通过 CAS 操作将自己的线程ID写入对象头的 Mark Word。如果成功，则进入偏向模式，锁标志位变为
01，且偏向模式标志为1。 - 执行：此后，只要这个线程再次进入同步块，只需检查 Mark Word 中的线程ID是否是自己。如果是，则无需任何同步操作（如CAS、系统互斥）直接执行，极大提升性能。
- 撤销：一旦出现另一个线程来尝试竞争锁，偏向锁就会撤销（Revoke Bias）。撤销过程需要等待全局安全点（STW），然后检查原持有偏向锁的线程是否仍活跃。如果活跃，则锁升级为轻量级锁；如果已不活跃，则可将对象置为无锁状态，重新偏向新的线程。
- 加锁：当一个线程第一次访问同步块时，它会通过 CAS 操作将自己的线程ID写入对象头的 Mark Word。如果成功，则进入偏向模式，锁标志位变为
轻量级锁 (Lightweight Locking) (00)
- 目的：在有多线程竞争，但竞争时间错开（即近乎交替执行）的场景下，避免线程直接进入阻塞，减少用户态到内核态的切换开销。
- 加锁流程：
- 线程在执行同步块之前，JVM 会先在当前线程的栈帧中创建一个名为锁记录（Lock Record）的空间。
- 将对象头的 Mark Word 复制到线程的锁记录中（称为 Displaced Mark Word）。
- 线程尝试通过CAS操作将对象头的 Mark Word 替换为指向其锁记录的指针。
- 如果成功，当前线程获得锁，锁标志位变为
00。 - 如果失败，表示至少有一条线程与当前线程竞争，当前线程会尝试自旋（循环重试CAS操作）来获取锁。
- 解锁流程：
- 使用 CAS 操作将 Displaced Mark Word 替换回对象头。
- 如果成功，表示没有竞争发生。
- 如果失败，表示当前锁存在竞争，锁会膨胀为重量级锁，并在解锁时唤醒等待的线程。
- 自旋优化：线程不会立即阻塞，而是循环尝试获取锁。避免了线程上下文切换的开销，但会消耗CPU。如果自旋过度（如自旋次数超过阈值，或竞争的线程数过多），锁会直接升级为重量级锁。
重量级锁 (Heavyweight Locking) (10)
- 目的：处理高并发、激烈竞争的场景。
- 流程：当轻量级锁竞争失败后，会膨胀为重量级锁。此时，Mark Word 中存储的是指向一个互斥量（Mutex）的指针，这个互斥量由操作系统内核提供。
- 所有等待锁的线程都会进入阻塞状态（BLOCKED），不再消耗CPU。锁的获取和释放需要操作系统进行线程的挂起和唤醒，这个过程涉及到复杂的用户态到内核态的切换，开销最大。
锁升级状态总结表：
| 锁状态 | 存储内容 | 标志位 | 适用场景 |
|---|---|---|---|
| 无锁 | 对象的哈希码、分代年龄等 | 01 | 无竞争 |
| 偏向锁 | 持有偏向锁的线程ID、Epoch、分代年龄、偏向模式标志1 | 01 | 只有一个线程访问同步块 |
| 轻量级锁 | 指向栈中锁记录的指针 | 00 | 多个线程交替访问，低并发竞争 |
| 重量级锁 | 指向互斥量（Mutex）的指针 | 10 | 高并发，激烈竞争 |
3. 底层指令
- 同步代码块通过
monitorenter和monitorexit指令实现：- 进入同步块时执行
monitorenter，退出时执行monitorexit（包括正常退出和异常退出）。
- 进入同步块时执行
- 同步方法通过方法表中的
ACC_SYNCHRONIZED标志标识，JVM通过此标志判断是否需要同步。
三、注意事项
- 可重入性：
synchronized是可重入锁，同一线程可多次获取同一把锁。 - 锁对象不能为 null：同步代码块的锁对象不能是
null，否则会抛出NullPointerException。 - 性能考虑：
- 尽量减小同步范围（使用代码块而非整个方法）。
- 避免锁竞争激烈，否则会升级为重量级锁，降低性能。
- 与
Lock的区别：synchronized是关键字，JVM 级别实现；Lock是 API 级别实现。Lock更灵活（可中断、超时、公平锁等），但需手动释放锁。
wait/notify使用注意：- 必须在同步块内调用。
- 使用
while循环检查条件，防止虚假唤醒。 - 明确锁对象，调用
obj.wait()时必须持有obj的锁。
四、示例代码
publicclassSynchronizedExample{privatefinalObjectlock=newObject();privateintcount=0;// 同步实例方法publicsynchronizedvoidincrement(){count++;}// 同步静态方法publicstaticsynchronizedvoidstaticMethod(){// ...}// 同步代码块publicvoiddoSomething(){synchronized(lock){// 同步代码}}}总结
synchronized是 Java 中最基本的线程同步机制，通过 JVM 的 Monitor 和精细的锁升级策略（偏向锁->轻量级锁->重量级锁）实现了在高性能无竞争场景和高强度竞争场景下的自适应同步。其内置的wait/notify机制为线程间协调提供了基础。使用时需注意锁的范围、竞争情况以及wait/notify的正确用法，以避免性能问题和逻辑错误。对于更复杂的场景，可以考虑java.util.concurrent包中的高级并发工具。