synchronized 的内存语义可以解决共享变量内存可见性问题，此外synchronized 经常被用来实现原子性操作（例： signal++ 不是⼀个原⼦操作，需要使⽤ synchronized 给它“上锁”）。
场景：共享资源修改
// 银行账户扣款 public class Account { private double balance; public synchronized void deduct(double amount) { if (balance >= amount) { balance -= amount; } } }
public class Counter { private int count = 0; // 需要显式同步 public synchronized void increment() { count++; } public synchronized int getCount() { return count; } }
必要性：必须通过锁保证共享状态的一致性
可重入锁（Reentrant Lock）
public class ReentrantDemo { public synchronized void methodA() { System.out.println("Enter methodA"); methodB(); // 嵌套调用同步方法 } public synchronized void methodB() { System.out.println("Enter methodB"); } }
执行流程：
graph TB Thread[线程] -->|获取对象锁| methodA methodA -->|无需重新申请锁| methodB methodB -->|执行完毕| Release[释放锁]
关键点：同一个线程在持有锁的情况下，可以多次进入同一把锁保护的代码区域【可重入性仅适用于同一把锁（相同对象或 Class 对象）】
可重入性边界案例
public class StaticLock { public synchronized static void staticMethod() { instanceMethod(); // 非重入！锁对象不同 } public synchronized void instanceMethod() { ... } }
锁对象差异：
staticMethod 锁定 StaticLock.class
instanceMethod 锁定 this 实例
现代替代方案：ReentrantLock
private final ReentrantLock lock = new ReentrantLock(); public void execute() { lock.lock(); // 显式获取锁 try { nestedCall(); } finally { lock.unlock(); } } private void nestedCall() { lock.lock(); // 可重入获取 try { // ... } finally { lock.unlock(); } }
优势：
支持公平锁
提供 tryLock() 超时机制
可中断的锁获取
补充：可重入性设计的必要性
示例1：
public class BankAccount { public synchronized void transfer(BankAccount target, int amount) { this.withdraw(amount); // 重入 target.deposit(amount); } public synchronized void withdraw(int amount) { ... } public synchronized void deposit(int amount) { ... } }
解读：
业务逻辑：转账操作需原子性完成扣款和存款
技术支撑：可重入锁保证同步方法嵌套调用不阻塞
示例2：
class Base { public synchronized void baseMethod() { ... } } class Sub extends Base { @Override public synchronized void baseMethod() { super.baseMethod(); // 重入父类同步方法 // 子类扩展逻辑 } }
继承兼容：子类重写方法可通过 super 调用父类同步逻辑
JVM 执行机制
每个 Java 对象都与一个 monitor 关联（通过 ObjectMonitor 实现）：
// HotSpot JVM 源码 (objectMonitor.hpp) class ObjectMonitor { volatile intptr_t _count; // 锁重入计数器 volatile intptr_t _owner; // 持有锁的线程指针 volatile intptr_t _recursions; // 重入次数 };
重入过程：
首次加锁：_owner = current_thread, _count = 1
重入时：_count++, _recursions++
解锁时：_count--，直到 _count = 0 时真正释放锁
对象级锁
核心定义：当需要同步非静态方法或非静态代码块时，对象级锁确保在同一个类的特定实例上，只有一个线程能执行该同步代码
关键特性：
锁绑定到具体对象实例（this）
不同实例的锁相互独立
实例销毁时锁自动释放
补充：
下⾯这两个⽅法是等价的
类级锁
核心定义：类级锁用于同步静态方法或静态代码块，确保在任何时候只有一个线程能访问类的静态数据
public class GlobalConfig { private static int configVersion = 0; // 类级锁实现方式1：静态同步方法 public static synchronized void updateConfig() { configVersion++; } // 实现方式2：同步类对象 public static void safeUpdate() { synchronized (GlobalConfig.class) { // 锁定Class对象 configVersion++; } } }
关键特性：
锁绑定到类的Class对象（ClassName.class）
所有实例共享同一把锁
JVM卸载类时锁释放
补充：
下⾯这两个⽅法是等价的
对比分析
（1）需精准识别临界区
（2）要处理锁嵌套和死锁风险
（3）必须考虑锁粒度（方法锁 vs 代码块锁）
最佳实践：优先使用同步块而非同步方法，明确锁范围
graph LR Thread1-->|等待锁| CriticalSection[临界区] Thread2-->|阻塞| CriticalSection Thread3-->|阻塞| CriticalSection
锁竞争代价：
（1）线程切换开销：Linux 下约 1-10μs/次
（2）吞吐量衰减：高并发时性能曲线呈断崖式下降
// HotSpot JVM 锁实现伪代码 void ObjectMonitor::enter() { if (TryLock()) return; // 快速路径 if (TrySpin()) return; // 自旋优化 EnqueueToWaitList(); // 加入等待队列 Park(); // 挂起线程（内核切换） }
性能陷阱：
锁膨胀：无竞争→偏向锁→轻量级锁→重量级锁
等待队列管理：O(n) 复杂度的唤醒操作
此内容由惯性聚合(RSS阅读器)自动聚合整理，仅供阅读参考。 原文来自 — 版权归原作者所有。