一、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();// 生产完成，通知消费者}}}

关键点：

1. 总是需要在循环中调用wait()以防止虚假唤醒（Spurious Wakeup），即线程可能在没有被通知、中断或超时的情况下醒来。
2. wait()会释放锁，而sleep()不会。
3. 通常更推荐使用notifyAll()，因为notify()是随机唤醒，可能导致某些线程永远无法被唤醒（线程饥饿）。

二、底层原理

synchronized的底层实现依赖于 JVM 内部的监视器锁（Monitor）机制，主要涉及以下概念：

1. 对象头与 Mark Word

• 在 HotSpot 虚拟机中，每个对象都有一个对象头，其中包含Mark Word（标记字段）。
• Mark Word 的长度为 32位 或 64位，用于存储对象的哈希码、分代年龄、锁状态标志位等信息。锁的状态就记录在这里。

2. 锁升级的详细过程

为了平衡性能与安全性，JVM 对synchronized进行了优化，引入了锁升级机制。这个过程是单向的：无锁 → 偏向锁 → 轻量级锁 → 重量级锁。

1. 无锁状态 (01)

   • 初始状态，对象刚被创建，尚未有任何线程竞争。

2. 偏向锁 (Biased Locking) (01)

   • 目的：消除在无竞争情况下的同步开销。假设在大多数情况下，锁不仅不存在多线程竞争，而且总是由同一线程多次获得。
   • 流程：
     • 加锁：当一个线程第一次访问同步块时，它会通过 CAS 操作将自己的线程ID写入对象头的 Mark Word。如果成功，则进入偏向模式，锁标志位变为01，且偏向模式标志为1。
     • 执行：此后，只要这个线程再次进入同步块，只需检查 Mark Word 中的线程ID是否是自己。如果是，则无需任何同步操作（如CAS、系统互斥）直接执行，极大提升性能。
     • 撤销：一旦出现另一个线程来尝试竞争锁，偏向锁就会撤销（Revoke Bias）。撤销过程需要等待全局安全点（STW），然后检查原持有偏向锁的线程是否仍活跃。如果活跃，则锁升级为轻量级锁；如果已不活跃，则可将对象置为无锁状态，重新偏向新的线程。

3. 轻量级锁 (Lightweight Locking) (00)

   • 目的：在有多线程竞争，但竞争时间错开（即近乎交替执行）的场景下，避免线程直接进入阻塞，减少用户态到内核态的切换开销。
   • 加锁流程：
     • 线程在执行同步块之前，JVM 会先在当前线程的栈帧中创建一个名为锁记录（Lock Record）的空间。
     • 将对象头的 Mark Word 复制到线程的锁记录中（称为 Displaced Mark Word）。
     • 线程尝试通过CAS操作将对象头的 Mark Word 替换为指向其锁记录的指针。
     • 如果成功，当前线程获得锁，锁标志位变为00。
     • 如果失败，表示至少有一条线程与当前线程竞争，当前线程会尝试自旋（循环重试CAS操作）来获取锁。
   • 解锁流程：
     • 使用 CAS 操作将 Displaced Mark Word 替换回对象头。
     • 如果成功，表示没有竞争发生。
     • 如果失败，表示当前锁存在竞争，锁会膨胀为重量级锁，并在解锁时唤醒等待的线程。
   • 自旋优化：线程不会立即阻塞，而是循环尝试获取锁。避免了线程上下文切换的开销，但会消耗CPU。如果自旋过度（如自旋次数超过阈值，或竞争的线程数过多），锁会直接升级为重量级锁。

4. 重量级锁 (Heavyweight Locking) (10)

   • 目的：处理高并发、激烈竞争的场景。
   • 流程：当轻量级锁竞争失败后，会膨胀为重量级锁。此时，Mark Word 中存储的是指向一个互斥量（Mutex）的指针，这个互斥量由操作系统内核提供。
   • 所有等待锁的线程都会进入阻塞状态（BLOCKED），不再消耗CPU。锁的获取和释放需要操作系统进行线程的挂起和唤醒，这个过程涉及到复杂的用户态到内核态的切换，开销最大。

锁升级状态总结表：

3. 底层指令

• 同步代码块通过monitorenter和monitorexit指令实现：
  • 进入同步块时执行monitorenter，退出时执行monitorexit（包括正常退出和异常退出）。
• 同步方法通过方法表中的ACC_SYNCHRONIZED标志标识，JVM通过此标志判断是否需要同步。

三、注意事项

1. 可重入性：synchronized是可重入锁，同一线程可多次获取同一把锁。
2. 锁对象不能为 null：同步代码块的锁对象不能是null，否则会抛出NullPointerException。
3. 性能考虑：
   • 尽量减小同步范围（使用代码块而非整个方法）。
   • 避免锁竞争激烈，否则会升级为重量级锁，降低性能。
4. 与Lock的区别：
   • synchronized是关键字，JVM 级别实现；Lock是 API 级别实现。
   • Lock更灵活（可中断、超时、公平锁等），但需手动释放锁。
5. 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包中的高级并发工具。