Java 同步和内存可见性。 10 对其他线程可见吗？

Question

我有两节课。

一个类只是一个带有 get 和 set 同步方法的整数值的容器。

public class Sync {
   private int dataSync;

   public synchronized int getDataSync() {
       return dataSync;
   }

   public synchronized void setDataSync(int data) {
      dataSync = data;
   }
}

其他类类似。 它只是一个带有 get 和 set 方法的整数值的容器，没有同步。

public class NotSync {

   private int dataNotSync;

   public int getDataNotSync() {
      return dataNotSync;
   }

   public void setDataNotSync(int data) {
      dataNotSync = data;
   }
}

现在我的问题是“10 值保证对所有其他线程可见”在运行方法结束时。

public class RunSync {

   public static void main(String[] args) {
      RunSync rs = new RunSync();
      rs.run();
   }

   private NotSync dataNS;

   private Sync    dataS;

   private int     data;

   public RunSync() {
      dataS = new Sync();
      dataNS = new NotSync();
   }

   public synchronized void run() {
      data = 100;
      dataS.setDataSync(45);
      dataNS.setDataNotSync(10);
      //Question A: is 10 value guaranteed to be visible to all other
      //threads when method exits?
      //we are inside a synchronized block aren't we? 
      //so all writes must be flushed to main memory
   }
}

编辑：想象一下还有其他线程。这只是一个快速编写的示例。问题是当同步块完成时，究竟保证什么会刷新回主内存。

EDIT2：根据java内存模型 “只有在某些情况下，才能保证一个线程对字段所做的更改对其他线程可见。一种情况是写入线程释放同步锁，而读取线程随后获取相同的同步锁。

那么如果另一个线程获得了 RunSync 锁，是否可以保证在 RunSync 的 NotSync 实例中看到 10？即使 NotSync 不受保护？

Edit3：没有明确答案的相关问题。我还在寻找。 What is the scope of memory flushed or published to various threads when using volatile and synchronized?

EDIT4：为了简化示例，RunSync 类中的这个方法怎么样

public synchronized void run2() {
    dataNS.setDataNotSync(10);
}

run2 退出时，什么都不能保证刷新到主存？一个明确的答案将回答我的问题。如果否，则意味着只有锁的成员才能保证被刷新，并且如果其他线程在 RunSync 上获取相同的锁，其他线程将可以看到该成员。 答案是不保证。

EDIT5：在这种情况下，断言是否保证为真？

public class RunSync {

public volatile boolean was10Written = false;

    public synchronized void run2() {
      dataNS.setDataNotSync(10);
      was10Written = true;
   }

   public void insideAnotherThread() {
      if(was10Written) {
         int value = dataNS.getDataNotSync();
         assert value == 10;
      }
   }
}

Answer 1

答案是否定的，不保证可见，但可以。由于 10 的写入是不同步的，因此对于同步读取而言，在排序之前不会发生任何事情。

根据Java内存模型“一个线程对字段所做的更改保证仅在某些条件下对其他线程可见。

如果一个线程的写入发生在同步操作之前，这是正确的。对 10 的写入发生在之后，因此没有可见性保证。

例如，如果您有一个新字段并在写入 dataSync（同步）之前将其写入为 10，并且您将 dataSync 评估为 45，那么对新字段的写入将是可见的。

Answer 2

答案是RunSync类中原始代码中dataNS.dataNotSync数据成员中的值10肯定会被任何其他在rs对象上同步的线程可见，并且在主线程获得rs的锁之后从 rs.run() 方法中退出。 dataNS.setDataNotSync(10);调用是在同步块内（在对象 rs 上）进行的，因此 JMM 在释放 rs 锁之前对主线程所做的任何变量所做的任何写入都将可见（之前发生过）任何线程随后获得 rs 上的锁，然后读取这些变量。

请注意，任何线程在主线程进行更改时只是休眠，然后尝试读取 dataNS 的值而不获得 rs 上的锁，不能保证看到值 10，因为没有发生 -在它们之间建立读取 dataNS 和写入 dataNS 的主线程之间的关系之前。

例如，在下面完成的 main() 方法中，线程 t1 保证打印 10，但这是因为我们在 rs.run() 代码执行后启动线程 t1；如果我们替换了 rs.run() 的顺序；和 t1.start();仅当 t1 在 rs.run() 获得锁（并完成）后获得锁时，才会打印值 10：

public static void main(String[] args) {
    RunSync rs = new RunSync();
    Thread t1 = new Thread() {
        public void run() {
            synchronized(rs) {
                System.out.println(rs.dataNS.getDataNotSync());  
            }  
        }
    };
    rs.run();
    t1.start();
}

如果在上面的代码中我们写“t1.start();”然后是“rs.run()”，为了让 t1 保证打印 10，我们需要在线程的 run() 中编写一个“while(cond) rs.wait()”语句，这将保证我们不会在 rs.run() 从主线程完成执行之前读取 dataNS 值，并且我们需要调用 rs.notify() 作为 rs.run() 方法的最后一条语句。

Answer 3

还有哪些线程？无论如何，您应该看到关键字 volatile 开始。此外，同步一种方法不会同步实例变量以进行读/写。因此，如果一个线程正在写入，另一个线程可能正在读取不同的值，因为只有方法是同步的（一次只有一个线程在设置值，而一个线程正在读取，但您可以同时在同一时间