深入理解Java中的嵌套同步锁：何时冗余，何时关键

本文深入探讨java中`synchronized`方法与内部`synchronized`块的交互。我们将分析在何种情况下，对私有字段的嵌套同步是多余的，以及在哪些场景下，它对于确保跨不同同步上下文的线程安全至关重要。教程将通过代码示例，阐明锁对象的作用及其对并发行为的影响，指导开发者进行正确的并发代码设计和重构。

在Java并发编程中，synchronized关键字是实现线程安全的核心机制之一。它可以通过锁定对象来确保在同一时刻只有一个线程可以执行特定的代码块或方法。然而，当synchronized方法内部包含对私有字段的额外synchronized块时，开发者常会对其必要性产生疑问。理解这种嵌套同步的语义及其对Java内存模型（JMM）的影响，对于编写高效且正确的并发代码至关重要。

理解Java中的同步机制

Java的synchronized关键字可以应用于方法或代码块：

1. synchronized方法：当一个实例方法被声明为synchronized时，它会锁定当前实例对象（this）。这意味着在任何给定时间，只有一个线程可以执行该对象的任何synchronized实例方法。对于静态synchronized方法，它会锁定该方法所属的Class对象。

2. synchronized代码块：synchronized (object)形式的代码块会锁定指定的object。只有获取了该object锁的线程才能进入并执行该代码块。这提供了更细粒度的控制，允许开发者仅同步关键部分，而不是整个方法。

   立即学习“Java免费学习笔记（深入）”；

理解这两种机制的关键在于它们锁定的对象不同。synchronized方法锁定的是方法所属的实例（或类），而synchronized块锁定的是显式指定的对象。

初始场景分析：synchronized方法与内部字段同步

考虑以下一个典型的Java类结构，其中flushSink方法既是synchronized的，其内部又对一个私有字段sink进行了同步：

public class Wrapper {
  private volatile Sink sink; // Sink是一个自定义接口或类

  public synchronized void flushSink() {
    if (sink != null) {
      synchronized (sink) { // 内部同步块
        sink.flush();
      }
    }
  }

  public void close() throws IOException {
    var currentSink = this.sink; // 读取volatile字段
    if (currentSink != null) {
      currentSink.receivedLast();
    }
  }
}

interface Sink {
    void flush();
    void receivedLast();
}

在这个Wrapper类中，flushSink()方法被声明为synchronized，这意味着任何线程在调用flushSink()之前都必须获取Wrapper实例的锁（即this锁）。一旦进入方法体，它又会尝试获取sink对象的锁来执行sink.flush()。

内部同步块的冗余性分析

如果flushSink()是唯一会访问sink对象并对其进行操作的synchronized方法，并且没有其他地方会对sink对象本身进行同步，那么内部的synchronized (sink)块确实是冗余的。原因如下：

• 当一个线程进入flushSink()方法时，它已经持有了Wrapper实例的锁。
• 由于Wrapper实例锁的存在，同一时刻只有一个线程能够执行flushSink()方法。
• 因此，当一个线程在flushSink()内部访问sink字段并调用sink.flush()时，不会有其他线程同时在flushSink()内部访问同一个sink字段。

在这种特定情况下，代码可以简化为：

钉钉 AI 助理

钉钉AI助理汇集了钉钉AI产品能力，帮助企业迈入智能新时代。

21

查看详情

public class Wrapper {
  private volatile Sink sink;

  public synchronized void flushSink() {
    if (sink != null) {
      sink.flush(); // 直接调用，无需内部同步
    }
  }
  // ... 其他方法保持不变
}

此外，为了进一步增强健壮性，尤其是在sink字段可能被其他线程（即使是未同步的）修改的情况下，通常建议在synchronized方法内部将volatile字段读取到局部变量中，以确保操作的原子性：

public class Wrapper {
  private volatile Sink sink;

  public synchronized void flushSink() {
    var currentSink = this.sink; // 将volatile字段读取到局部变量
    if (currentSink != null) {
      currentSink.flush();
    }
  }
  // ... 其他方法保持不变
}

即使sink是volatile的，volatile只能保证sink引用的可见性，不保证sink对象上操作的原子性。但在synchronized方法内部，this锁已经提供了足够的保护，确保了this.sink的读取和后续操作的原子性。将this.sink赋值给局部变量currentSink在synchronized方法中主要是为了避免在null检查和方法调用之间sink被其他线程设置为null（如果sink的更新操作本身没有被this锁保护）。

内部同步块的必要性：跨不同同步上下文的协调

然而，上述简化并非总是适用。内部的synchronized (sink)块在特定场景下是至关重要的，尤其当存在其他代码路径也需要对sink对象进行同步时。

考虑close()方法被修改为也对sink对象进行同步的情况：

public class Wrapper {
  private volatile Sink sink;

  public synchronized void flushSink() {
    if (sink != null) {
      synchronized (sink) { // 内部同步块，现在变得关键
        sink.flush();
      }
    }
  }

  public void close() throws IOException {
    var currentSink = this.sink;
    if (currentSink != null) {
      synchronized(currentSink) { // 对sink对象进行同步
        currentSink.receivedLast();
      }
    }
  }
}

在这种情况下，flushSink()方法中的synchronized (sink)块就不能被移除。原因在于：

1. flushSink()方法锁定的是Wrapper实例（this）。
2. close()方法锁定的是sink实例（currentSink）。

如果移除了flushSink()中的synchronized (sink)，那么一个线程可能正在执行flushSink()（持有Wrapper实例锁），同时另一个线程正在执行close()（持有sink实例锁）。这样，sink.flush()和sink.receivedLast()就有可能在同一个sink对象上并发执行，从而导致数据不一致或竞态条件。

通过在flushSink()和close()中都对sink对象进行同步，我们确保了在任何给定时刻，sink对象上的flush()和receivedLast()方法不会并发执行。这是因为它们都必须获取同一个sink对象的锁才能执行。

总结与最佳实践

• 冗余判断：对私有字段的嵌套synchronized块只有在以下条件都满足时才是冗余的：
  1. 外部方法（或代码块）已经对一个包含该私有字段的更广范围的对象（例如this）进行了同步。
  2. 没有其他代码路径会直接对该私有字段对象本身进行同步。
• 必要性判断：当需要协调对某个共享对象（如sink）的访问，并且这些访问可能来自不同的同步上下文（即由不同的锁保护的代码块或方法）时，对该共享对象进行显式同步是必要的。
• volatile与synchronized：volatile确保字段引用的可见性，即一个线程对sink字段的写入对所有其他线程都是可见的。而synchronized则提供了互斥性和内存可见性，确保了操作的原子性，并强制了内存屏障，使得在同步块内部对共享变量的修改对后续获取同一锁的线程可见。
• 设计原则：在设计并发代码时，应明确每个共享资源由哪个锁保护。如果一个资源需要在多个独立的代码路径中被安全访问，那么这些路径都应该使用同一个锁对象来同步对该资源的访问。

在进行此类重构时，务必全面审查代码库中所有访问共享字段的地方，以确保不会引入新的并发问题。如果存在不确定性，保留更严格的同步机制通常是更安全的做法。

以上就是深入理解Java中的嵌套同步锁：何时冗余，何时关键的详细内容，更多请关注php中文网其它相关文章！