为什么将虚拟对象作为块级同步的参数传递？

Question

在 Spring 源代码中找到了这段代码。这是将 XML 文件转换为 Bean Tree 的第一步。

/** Synchronization monitor for the "refresh" and "destroy" */
    private final Object startupShutdownMonitor = new Object();

public void refresh() throws BeansException, IllegalStateException {
        synchronized (this.startupShutdownMonitor) {
            // Prepare this context for refreshing.
            prepareRefresh();
}

Answer 1

该习惯用法用于更精细的级别同步。以下是 Java 教程 的摘录。您可以使用synchronized(this)，但它会锁定整个对象。

同步语句对于提高并发性也很有用
细粒度同步。例如，假设 MsLunch 类有
两个实例字段 c1 和 c2 从不一起使用。全部
这些字段的更新必须同步，但没有理由这样做
防止 c1 的更新与 c2 的更新交错 —
这样做会产生不必要的阻塞，从而减少并发性。
而不是使用同步方法或以其他方式使用锁
与此相关的是，我们创建两个对象只是为了提供锁。

public class MsLunch {
    private long c1 = 0;
    private long c2 = 0;
    private Object lock1 = new Object();
    private Object lock2 = new Object();

    public void inc1() {
        synchronized(lock1) {
            c1++;
        }
    }

    public void inc2() {
        synchronized(lock2) {
            c2++;
        }
    }
}

从 Java 5 开始，java 引入了 Lock 抽象提供更多功能。因此，您可以执行如下操作，而不是使用synchronized(obj)。了解更多详细信息

Lock lock = new ReentrantLock();

lock.lock();

c1++;

lock.unlock();

Answer 2

我不能具体代表 Spring 作者，但总的来说......

这样做是为了使代码同步（显然），但故意不在 this 上同步。

我们为什么要这样做？有几个原因：

1. 该类中还有其他同步块，但这些块与此块之间不存在相互依赖性。因此，它们不应该围绕同一个锁进行同步 - 每个资源都围绕不同的对象进行同步。
2. 您想要对您班级的用户隐藏该锁。始终存在这样的风险：您的某个用户可能决定执行 synchronized(theObject) 并最终在类外部使用与您在类内部使用的相同对象作为锁。在某些情况下，这可能会导致严重的性能/并发问题

为什么要使用对象？因为这就是获得锁所需要的一切，其他任何东西都会带来更多的开销。

Answer 3

我假设您从根本上想知道为什么他们不使用synchronized(this)？您发布的代码可能更好的原因大致有两个。

1. 安全（或者更确切地说，行为的确定性）。由于其他类可能引用您的类的实例，因此它们也可以自由地对其进行同步。 （事实上​​，每次不在this上同步时，几乎肯定是在另一个类的监视器上同步）。您可以编写代码，使其独立工作，但如果其他代码使用它以特定方式同步，则会产生死锁。在 this 上同步实际上是公开的，但我怀疑您通常会记录它（或者其他开发人员会阅读该文档）。通过在这样的私有最终字段上进行同步，您可以保证没有其他代码可以在同一对象上进行同步，从而极大地简化了您需要保护的逻辑。
2. 同一类中的多个操作。例如，如果您有两个单独的计数器，并且正在使用同步来防止丢失更新，那么写入计数器 1 就没有理由阻止读取计数器 2。如果一切都在 this< 上同步/code>，那么这些方法中只能同时发生其中一种。通过对特定对象进行同步，您可以创建组内互斥的方法/块组，但不会阻止其他组中的块继续进行。

第一个可以说是最重要的，因为它可能会设置一个非常难以调试的定时炸弹。第二个也是相关的 - 开发人员经常在没有意识到的情况下过度限制独立的操作 - 但仅适用于同一类中确实有多个操作组的情况。

如今，如果我要同步，我总是会在特定的 new Object() 字段上进行同步，即使目前只是一个操作。

Answer 4

啊，我以前见过这个:)我实际上也思考过同样的事情。

如果我没记错的话，这是来自 AbstractApplicationContext 。

将一个方法标记为同步意味着没有 2 个线程可以同时调用该方法或任何其他同步方法（锁位于类上）。

拥有一个监视器对象并在同步块中使用它具有相同的效果，但对于使用相同虚拟对象的同步块中的所有代码而言。

如果我没记错的话，在同一个类中还有另一个监视器，称为 activeMonitor。

这允许更高的并发性（线程同时访问两个对象同步的方法）。

这可以让他安全地避免将他的监视器（他的班级之外的任何人都没有兴趣）泄露给其他可能滥用它的对象（将其置于永久权限状态），从而在这个过程中弄乱他的监视器。

Answer 5

如果一段代码具有某些类变量，并且彼此完全独立，那么与其使用 synchronize(this) 获取整个对象的锁，不如对虚拟对象使用锁。里面的代码仍然受到保护，因为监视器现在处于虚拟对象锁定状态。

Answer 6

private final Object startupShutdownMonitor = new Object();

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
       // Prepare this context for refreshing.
       prepareRefresh();
   }

}

这相当于以下内容：

public void refresh() throws BeansException, IllegalStateException {
      //Do something that does not affect the state of the object
      System.out.println("I am inside the refresh method() and will accquire lock on the object now");
      prepareRefresh();
}

private synchronized void preparedRefresh() {
    //Do something thread safe here
    //Since the thread here has the monitor it can safely alter the state of the class instance here with causing inconsistensy
}

获取实例对象 startupShutdownMonitor 的锁与获取调用刷新方法的类的实例的锁相同。