同步块是否会导致所有写入缓存刷新？

Question

我对@9​​87654323@ 如何/何时从本地缓存刷新写入感兴趣。假设我有以下代码：

class Scratch1 {
  int counter = 0;
  Scratch1() throws ExecutionException, InterruptedException {
    counter += 5;
    counter += 5;
    // Does this cause to flush possibly cached value written by main thread even if it locks
    // on totally unrelated object and the write doesnt happen inside the sync block?
    synchronized (String.class) {}
    Executors.newCachedThreadPool().submit(() -> {
      for (int i = 0; i < 1000; i++) {
        counter += 5;
      }
      synchronized (Integer.class) {}
    }).get();
    System.out.println(counter);
  }
}

class Scratch2 {
  int counter = 0;
  Scratch2() throws ExecutionException, InterruptedException {
    // Or is this only possible working way how flush written data.
    synchronized (String.class) {
      counter += 5;
      counter += 5;
    }
    Executors.newCachedThreadPool().submit(() -> {
      synchronized (Integer.class) {
        for (int i = 0; i < 1000; i++) {
          counter += 5;
        }
      }
    }).get();
    System.out.println(counter);
  }
}

class Scratch3 {
  volatile int counter = 0;
  Scratch3() throws ExecutionException, InterruptedException {
    counter += 5;
    counter += 5;
    Executors.newCachedThreadPool().submit(() -> {
      for (int i = 0; i < 1000; i++) {
        counter += 5;
      }
    }).get();
    System.out.println(counter);
  }
}

我有几个问题：

1. 所有三个示例是否共享相同的“线程安全”级别（考虑到第一次写入由一个线程完成，第二次写入在第一个（是吗？）和另一个线程之后完成）即“是保证打印 5010”？
2. 在同步块之外“操作”或使用非易失性属性时是否存在性能差异（至少理论上）（我预计易失性访问会像this post confirms 一样慢）但在同步块的情况下是“刷新”的价格仅在跨越同步开始/结束时支付，还是在块内也有差异？

Answer 1

我对同步的工作原理感兴趣，即它如何/何时刷新本地缓存中的写入。

实际上，synchronized 不会刷新本地缓存中的写入。它只是表现得好像它这样做了。

所有三个示例是否共享相同的“线程安全”级别（考虑到第一次写入由一个线程完成，第二次写入在第一个线程之后完成（是吗？）和另一个线程完成）即“是保证打印 10”？

它们都提供略有不同的线程安全形式。如果其他线程同时访问该对象，它们都不是真正安全的。例如，访问counter 的另一个线程必须同时持有String.class 和Integer.class 锁，以确保它在操作期间看不到counter。第三个使用非原子的增量操作，但如果没有其他线程尝试修改counter，它是安全的。

在同步块之外“操作”或使用非易失性属性是否存在性能差异（至少理论上）（我希望 volatile 访问会更慢，正如这篇文章所证实的那样），但在同步块的情况下是“刷新”的价格只在跨越同步开始/结束时支付，还是在块内也有差异？

没有区别。进入synchronized 块是有代价的，因为必须获取锁并且必须在入口点禁用一些优化。退出街区的成本相似。

在块内部，没有成本，因为程序员提供了安全性，确保他们不允许任何线程修改对象，除非它持有相同的锁并且没有两个线程可以同时持有相同的锁.一般来说，代码甚至可能不知道它是否在一个或多个 synchronized 块内，因为它可能位于调用树的深处。