Java – did this happen before the program command rules worked in the constructor?

Can you really view partially constructed objects in the thread created in the constructor because of the lack of synchronization and disclosure of this instance?

Of course, in addition to subclasses, or we are using clone or something similar for implicit construction, let's assume that this class is final, and it is fully initialized in the thread that calls the constructor before calling other threads.

As far as I know, the following HB () rules apply,

>Each operation in the thread occurs before each operation in the thread, which later appears in the program order (program order rule) > before starting any operation in the thread, the start() call to the thread occurs. > If HB (x, y) and Hb (y, z), then HB (x, z)

So does it mean that the following code is technically thread safe (I start from a similar question why shouldn't I use thread. Start() in the constructor of my class? Why it is bad practice to create a new thread on constructors?, p. S. I hope this will not be closed as a repeat)

final class SomeClass
{
    public ImportantData data = null;
    public Thread t = null;

    public SomeClass(ImportantData d)
    {
        t = new MyOperationThread();

        // t.start(); // Footnote 1

        data = d;

        t.start();    // Footnote 2
    }
}

PS: obviously, the data field lacks encapsulation here, but this problem is about the state visibility of objects from thread t

Solution

Yes, it does Clear specifications:

Of course, when the constructor is completed, the object is not guaranteed to be fully initialized, because the constructor can call other constructors - through explicit constructor invocation statement, or because the superclass default constructor is implicitly called Therefore, it is quite fragile to leak it from the constructor - with single or multiple threads