在实践中，对象构造是否可以保证所有线程都看到初始化的非最终字段?

本文介绍了在实践中，对象构造是否可以保证所有线程都看到初始化的非最终字段?的处理方法，对大家解决问题具有一定的参考价值，需要的朋友们下面随着小编来一起学习吧！

问题描述

Java内存模型保证对象的构造和终结器之间发生先发生后关系:

The Java memory model guarantees a happens-before relationship between an object's construction and finalizer:

以及构造函数和final字段的初始化:

As well as the constructor and the initialization of final fields:

对于volatile字段也有保证，因为关于对这些字段的所有访问都存在事前发生的关系:

There's also a guarantee about volatile fields since, there's a happens-before relations with regard to all access to such fields:

但是，常规的，良好的旧非易失性字段呢?我已经看到了很多多线程代码，这些对象在使用非易失性字段构造对象之后不会麻烦创建任何类型的内存屏障.但是由于这个原因，我从未见过或听说过任何问题，而且我自己也无法重新创建这种局部构造.

But what about regular, good old non-volatile fields? I've seen a lot of multi-threaded code that doesn't bother creating any sort of memory barrier after object construction with non-volatile fields. But I've never seen or heard of any issues because of it and I wasn't able to recreate such partial construction myself.

现代JVM是否在构造后就设置了内存屏障?避免在施工前后重新排序?还是我只是幸运?如果是后者，是否可以编写可随意复制部分构造的代码?

Do modern JVMs just put memory barriers after construction? Avoid reordering around construction? Or was I just lucky? If it's the latter, is it possible to write code that reproduces partial construction at will?

为澄清起见，我正在谈论以下情况.假设我们有一堂课:

To clarify, I'm talking about the following situation. Say we have a class:

public class Foo{
    public int bar = 0;

    public Foo(){
        this.bar = 5;
    }
    ...
}

一些线程T1实例化了一个新的Foo实例:

And some Thread T1 instantiates a new Foo instance:

Foo myFoo = new Foo();

然后将实例传递给其他线程，我们将其称为T2:

Then passes the instance to some other thread, which we'll call T2:

Thread t = new Thread(() -> {
     if (myFoo.bar == 5){
         ....
     }
});
t.start();

T1执行了两次有趣的写操作:

T1 performed two writes that are interesting to us:

T1将值5写入新实例化的myFoo

bar

T1将对新创建对象的引用写到myFoo变量

T1 wrote the value 5 to bar of the newly instantiated myFoo
T1 wrote the reference to the newly created object to the myFoo variable

对于T1，我们得到一个保证写入#1 发生之前写入#2:

For T1, we get a guarantee that write #1 happened-before write #2:

但是就T2而言，Java内存模型不提供这种保证.没有什么可以阻止它以相反的顺序看到写入.因此它可以看到一个完全构建的Foo对象，但是bar字段等于0.

But as far as T2 is concerned the Java memory model offers no such guarantee. Nothing prevents it from seeing the writes in the opposite order. So it could see a fully built Foo object, but with the bar field equal to equal to 0.

Edit2

写完几个月后，我再次看了一下上面的例子.自从T1写入后启动T2以来，实际上可以保证该代码正常工作.这使它成为我要提出的问题的错误示例.修复了假设T1在执行写操作时T2已经在运行的问题.假设T2正在循环读取myFoo，就像这样:

I took a second look at the example above a few months after writing it. And that code is actually guaranteed to work correctly since T2 was started after T1's writes. That makes it an incorrect example for the question I wanted to ask. The fix it to assume that T2 is already running when T1 is performing the write. Say T2 is reading myFoo in a loop, like so:

Foo myFoo = null;
Thread t2 = new Thread(() -> {
     for (;;) {
         if (myFoo != null && myFoo.bar == 5){
             ...
         }
         ...
     }
});
t2.start();
myFoo = new Foo(); //The creation of Foo happens after t2 is already running

such

在实践中，对象构造是否可以保证所有线程都看到初始化的非最终字段?

问题描述

推荐答案