当前位置：首页 > news >正文

java并发：synchronized 揭秘

news 2026/5/12 5:46:30

存量笔记，常读常新 ~ 再次回顾一下 Java 中的 synchronized 关键词

内存语义

进入 synchronized 块的内存语义是把在 synchronized 块内使用到的变量从线程的工作内存中清除，这样在 synchronized 块内使用变量时不会从线程的工作内存中获取，而是直接从主内存中获取。

退出 synchronized 块的内存语义是把在 synchronized 块内对共享变量的修改刷新到主内存。

其实上述内容也是加锁和释放锁的语义

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 TBThread[线程] -->|获取对象锁| methodAmethodA -->|无需重新申请锁| methodBmethodB -->|执行完毕| 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 {@Overridepublic 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 时真正释放锁

对象级锁（Instance-Level Lock） VS 类级锁（Class-Level Lock）

对象级锁

核心定义：当需要同步非静态方法或非静态代码块时，对象级锁确保在同一个类的特定实例上，只有一个线程能执行该同步代码

关键特性：

锁绑定到具体对象实例（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 LRThread1-->|等待锁| CriticalSection[临界区]Thread2-->|阻塞| CriticalSectionThread3-->|阻塞| CriticalSection

锁竞争代价：

（1）线程切换开销：Linux 下约 1-10μs/次
（2）吞吐量衰减：高并发时性能曲线呈断崖式下降

实现机制

// HotSpot JVM 锁实现伪代码
void ObjectMonitor::enter() {if (TryLock()) return;     // 快速路径if (TrySpin()) return;     // 自旋优化EnqueueToWaitList();       // 加入等待队列Park();                    // 挂起线程（内核切换）
}