Java Concurrency: What leads to the insecurity in object publication?

Question

Consider the following code:

public class Resource {
    public int val;
    public Resource() {
        val = 3;
    }
}

public class UnsafePublication {
    public static Resource resource;

    public static void initialize() {
        resource = new Resource();
    }
}

In Thread1

UnsafePublication.initialize();

In Thread2

while (true) {
    if (UnsafePublication.resource != null) {
        System.out.println(UnsafePublication.resource.val);
        break;
    }
}

We know that the unsafe publication may lead to Thread2 printing 0 instead of 3.

After going through many reference materials, I concluded two explanations:

1. Assume the assignment resource = new Resource(); does write through, so Thread2 will find UnsafePublication.resource is not null. But the assignment val = 3; in the constructor of Resource does not write through, so the val will be the default 0 value.

2. There is a reorder when assigning new Resource() to resource. To be more specific:

   1. allocate the memory for a Resource object
   2. call Resource' s constructor to initialize the object
   3. assign the object to the field "resource"

   is reordered to:

   1. allocate the memory for a Resource object
   2. assign the object to the field "resource"
   3. call Resource' s constructor to initialize the object.

   So if Thread1 just finishes the step2 in the reordered version, and Thread2 is swapped in, then Thread2 will find UnsafePublication.resource.val is the default 0 value.

So here is my question: Are both of the explanations correct and possible? And in the real world, are these two factors may even mixed to make the situation more complicated?

Answer 1

There are three possibilities here.

• Thread2 may view resource as null.
• Thread2 may view a reference to a partially constructed instance (i.e. memory is allocated on the heap, but the variables are not yet initialized), so the value of val variable might be zero.
• Thread2 may observe a fully constructed instance and the latest value of the variable, which is 3.

In fact, you can't predict the behavior of the program since there's no any happens before link established between the write and subsequent read operations. So, all the combinations of events are possible.