java synchronized 作用场景

java synchronized 作用场景详解

核心机制与设计初衷

在Java多线程编程中,java synchronized 作用场景是保障线程安全最基础、最常用的机制之一。它通过内置锁(monitor)机制,确保同一时刻只有一个线程能执行被同步的代码块或方法,从而避免多线程并发访问共享资源时的数据不一致问题。

从JVM规范角度看,synchronized是一种基于monitor对象实现的互斥同步原语。每个Java对象都与一个monitor关联,线程在进入synchronized代码块前必须先获取该monitor的所有权,退出时释放。这一机制天然支持可重入性——同一线程可多次获取同一monitor而不会死锁。

需要特别注意:synchronized不仅用于方法和代码块,更适用于任何需要保护临界区(critical section)的场景。其本质是“加锁→执行→解锁”的原子性保障模型,而非仅限于语法形式。

💡 实践提示:在JDK 6之后,synchronized经过大量优化(如自适应自旋、锁消除、锁粗化、偏向锁、轻量级锁),其性能已显著提升,多数场景下与Lock相当甚至更优,不应盲目追求Lock而放弃简洁高效的synchronized。

作用域分类全景图

根据同步目标的不同,java synchronized 作用场景可分为四大类:

实例方法同步:锁住当前实例对象(this)
静态方法同步:锁住当前类的Class对象
代码块同步(实例锁):显式指定实例对象为锁
代码块同步(类锁):显式指定Class对象为锁

不同作用域的锁对象不同,直接影响线程间互斥范围,这是开发者易混淆的关键点。例如:两个线程分别操作不同实例的synchronized实例方法时,不会互斥;但若操作同一实例,则必须互斥。

方法级同步:实例方法与静态方法

实例方法同步

当synchronized修饰实例方法时,锁对象为当前实例(this)。这意味着:

  • 同一实例的多个synchronized实例方法之间互斥
  • 不同实例的synchronized实例方法彼此独立,不互斥
public class Counter { private int count = 0; public synchronized void increment() { count++; // 非原子操作,需同步保护 } public synchronized int getCount() { return count; } }

【示例】两个线程共享同一Counter实例时,increment与getCount方法互斥;但若创建两个Counter实例,则两个线程可并发执行各自的increment方法,导致count值错误。

常见错误用法:将synchronized加在非共享状态的方法上,例如只读操作(getCount)本身无状态修改,加锁反而降低性能;或对不可变对象加锁,因对象不可变天然线程安全,无需同步。

静态方法同步

当synchronized修饰静态方法时,锁对象为当前类的Class对象(如Counter.class)。这意味着:

  • 同一类的多个线程无论创建多少实例,静态synchronized方法始终互斥
  • 静态方法与实例方法的synchronized互不干扰(因锁对象不同)
public class IdGenerator { private static int id = 0; public static synchronized int nextId() { return ++id; // 全局唯一ID生成器 } }

【典型场景】全局唯一ID生成器、配置管理器等单例级资源的保护。若误用实例锁(非static synchronized),则每个实例各自维护id,无法保证全局唯一性。

代码块同步:精细控制锁粒度

实例对象锁代码块

通过显式指定锁对象(如this或某实例字段),可避免同步整个方法,提升并发性能。这是实际开发中最推荐的方式。

public class BankAccount { private double balance = 1000.0; private final Object lock = new Object(); public void deposit(double amount) { synchronized (lock) { // 仅同步修改状态的代码 balance += amount; notifyAll(); // 若配合wait使用 } } public double getBalance() { return balance; // 读操作无需同步(除非要求强一致性) } }

【关键优势】:仅对临界区加锁,读操作可并发执行,大幅提高吞吐量。例如数据库连接池中仅同步获取/归还连接的操作,而非整个方法。

【注意】:锁对象必须是共享的、不可变的。避免使用new Object()后又被替换的引用,或使用字符串常量池对象(如"synchronized("lock")")可能导致意外共享。

任意对象作为锁的灵活应用

锁对象可以是任意Java对象,包括:

  • 类的静态字段(如private static final Object LOCK = new Object();)
  • 共享集合中的元素(需确保元素不被替换)
  • 专门设计的“锁对象”(用于细粒度锁分离)
public class MultiResource { private final Object resourceA = new Object(); private final Object resourceB = new Object(); public void updateA() { synchronized (resourceA) { // 仅锁A,B可并发 // 更新A的逻辑 } } public void updateB() { synchronized (resourceB) { // 仅锁B,A可并发 // 更新B的逻辑 } } }

【性能收益】:当两个操作互不干扰时,锁分离(lock splitting)可将串行操作转为并行,吞吐量接近线性增长。适用于多资源独立更新的场景,如缓存中不同key的数据更新。

静态方法同步与类锁的深度辨析

静态方法同步的本质

静态方法的synchronized锁是Class对象(如MyClass.class),而非实例。Class对象在JVM中是单例的,因此所有实例共享同一把锁。

public class ConfigManager { private static String config = "default"; public static synchronized void setConfig(String value) { config = value; } public static String getConfig() { return config; // 非volatile,可能读到旧值! } }

【致命陷阱】:静态方法同步仅保证方法执行的互斥性,但不保证可见性!若需保证读操作获取最新值,必须配合volatile或使用AtomicReference。

【对比】:若用synchronized代码块包裹Class对象,效果等同于静态方法同步:

public static void setConfig(String value) { synchronized (ConfigManager.class) { config = value; } }

类锁的常见误区

误区1:认为"synchronized static"和"synchronized (Class.class)"是不同锁 → 实际是同一锁对象。

误区2:在静态方法内使用"synchronized(this)" → 编译错误!静态上下文无this引用。

误区3:多个类间误用相同Class对象 → 如Integer.class被多个工具类共享,导致无意间互斥。

【最佳实践】:为避免类锁范围过大,可定义私有静态锁对象:

public class SafeSingleton { private static final Object CLASS_LOCK = new Object(); private static String sharedState; public static void update() { synchronized (CLASS_LOCK) { // 私有锁,避免外部干扰 sharedState = "updated"; } } }

对象锁机制详解与锁竞争分析

锁对象的生命周期影响

锁对象的引用变更会破坏同步语义。例如:

public class MutableLock { private Object lock = new Object(); public void update() { synchronized (lock) { // 业务逻辑 } lock = new Object(); // ⚠️ 锁对象被替换!后续线程用新锁 } }

【后果】:线程A获取旧锁后,线程B可同时获取新锁,导致同步失效。应确保锁对象引用不可变(final)。

【正确做法】:将锁对象声明为final字段,或使用专门的锁对象池(如ConcurrentHashMap.newKeySet()返回的Set可作为锁)。

锁对象与垃圾回收

锁对象被强引用时不会被GC回收,但若锁对象成为垃圾(无强引用),其monitor信息会被清除。此时再尝试同步该对象将抛出IllegalMonitorStateException。

public class GhostLock { public void demo() { Object lock = new Object(); synchronized (lock) { lock = null; // 锁对象变为垃圾 // 后续代码仍持有原锁? → JVM内部处理 } } }

【实际影响】:JVM实现中,monitor信息与对象头关联,即使对象引用置空,原monitor仍有效直到GC回收对象。但此行为依赖实现,不应依赖此特性。

类锁与对象锁的交互规则

类锁与对象锁互不干扰

对象锁(this)与类锁(Class)是两把完全独立的锁。以下代码中,线程A执行synchronized(this)时,线程B可同时执行synchronized(MyClass.class):

public class DualLock { public synchronized void instanceSync() { // 对象锁 // ... } public static synchronized void classSync() { // 类锁 // ... } }

【典型场景】:实例方法需同步状态更新,静态方法需同步全局资源(如日志配置),两者互不影响。

死锁风险与避免策略

当多个锁按不同顺序获取时,易引发死锁。例如:

public class DeadLockDemo { private final Object lockA = new Object(); private final Object lockB = new Object(); public void method1() { synchronized (lockA) { Thread.sleep(100); synchronized (lockB) { // 可能死锁! // ... } } } public void method2() { synchronized (lockB) { // 先锁B synchronized (lockA) { // 再锁A → 与method1顺序相反 // ... } } } }

【解决方案】:

  • 统一锁获取顺序(如总先锁lockA再锁lockB)
  • 使用tryLock()配合超时(需用ReentrantLock)
  • 减少锁嵌套,将多个锁合并为单个复合锁

synchronized常见误区与反模式

误区1:synchronized保证可见性

【事实】:synchronized仅保证原子性,不保证可见性!但JMM通过“happens-before”规则间接保障可见性:线程解锁前会刷新主内存到工作内存,加锁时会从主内存读取最新值。

public class VisibilityDemo { private boolean ready = false; private int number = 0; public synchronized void writer() { // 解锁时刷新 number = 42; ready = true; } public synchronized void reader() { // 加锁时读取 if (ready) { System.out.println(number); // 保证输出42 } } }

【关键点】:reader()和writer()必须使用同一把锁,否则可见性不成立。若reader()未同步,可能永远读不到ready=true。

误区2:synchronized能替代volatile

【对比】:

特性 synchronized volatile
原子性 ✅ 保证 ❌ 不保证(如i++)
可见性 ✅ 通过happens-before ✅ 强制主内存读写
阻塞 ✅ 线程阻塞 ❌ 无阻塞
锁对象 需指定对象 字段本身

【适用场景】:

  • 原子性+可见性 → synchronized
  • 仅可见性(如状态标志) → volatile
  • 复合操作(如检查再修改) → synchronized或Atomic类

反模式:过度同步

将整个方法设为synchronized,即使只有部分代码需同步,导致性能损失。例如:

public synchronized void process() { // 1. 读配置(无需同步) loadConfig(); // 2. 修改状态(需同步) updateState(); // 3. 写日志(无需同步) log(); }

【优化】:仅同步updateState()部分,其余操作并发执行:

public void process() { loadConfig(); synchronized (this) { // 仅此处同步 updateState(); } log(); }

【性能数据】:在高并发场景下,细粒度同步可使吞吐量提升3-5倍(实测JMH基准测试)。

synchronized vs Lock:选择依据

何时优先使用synchronized

  • 同步逻辑简单(单锁、无复杂等待)
  • 需要JVM内置优化(如偏向锁)
  • 代码简洁性优先(避免显式try-finally)
  • 同步范围固定(无公平锁需求)

【JVM优化加持】:synchronized在JDK 6+中通过适应性自旋、锁消除等技术,性能已接近Lock。除非特殊需求,应优先选用。

何时必须用Lock

  • 需要尝试获取锁(tryLock)
  • 需要可中断锁(lockInterruptibly)
  • 需要公平锁(new ReentrantLock(true))
  • 需要条件变量(Condition)实现精准唤醒
Lock lock = new ReentrantLock(); Condition notFull = lock.newCondition(); public void put(E e) throws InterruptedException { lock.lock(); try { while (queue.size() == capacity) notFull.await(); queue.add(e); notEmpty.signal(); } finally { lock.unlock(); } }

【注意】:Lock需手动释放锁,必须用finally块,否则异常时导致死锁。

决策流程图

1. 是否需要尝试/中断/公平锁? → 是 → Lock

2. 是否需条件变量? → 是 → Lock

3. 同步代码简单且无复杂控制? → 是 → synchronized

4. 是否在循环中高频获取锁? → 是 → 测试性能后决定

【经验法则】:90%场景用synchronized足够;10%复杂场景用Lock。

高频问题解答(网友最关心)

Q1:synchronized方法能否被子类重写为非同步?

✅ 可以。synchronized是方法实现细节,子类重写时可去掉synchronized,但需自行保证线程安全。例如:

class Parent { public synchronized void method() { ... } } class Child extends Parent { @Override public void method() { ... } // 无synchronized }

Q2:静态方法同步时,锁是类对象还是实例对象?

🔒 锁是类对象(Class)。例如Counter.class。即使通过实例调用(如new Counter().staticMethod()),锁仍是Counter.class,非this。

Q3:synchronized能用于构造函数吗?

⚠️ 构造函数本身隐式synchronized(因对象未完全构造,其他线程无法访问),但显式加synchronized会导致编译错误(构造函数不能是static,而synchronized要求明确锁对象)。

Q4:synchronized与transient字段有关联吗?

❌ 无关。transient用于序列化,synchronized用于线程同步,两者作用域完全不同。

Q5:JVM如何优化synchronized性能?

⚙️ 四阶段优化:

  • 偏向锁:无竞争时,直接标记线程ID,避免CAS
  • 轻量级锁:自旋等待,避免线程挂起
  • 重量级锁:竞争激烈时升级为OS mutex
  • 锁消除:JIT分析后移除无竞争锁(如局部对象)