Read field stale value after object construction

I tried to test the problem with the following code.

Test:

public class Test {    public static boolean flag =true;    public static HolderContainer hc=new HolderContainer();    public static void main (String args[]){            new Thread(new Initialization()).start();        new Thread(new Checking()).start();    }}class Initialization implements Runnable {    public void run() {        while (Test.flag){            Test.hc=new HolderContainer();            Test.hc.init();            }    }}class Checking implements Runnable {    public void run() {        try{            Test.hc.holder.assertValue();        }        catch (NullPointerException e) {        }        }}

Holder:

public class Holder {    private int value;        public Holder(int value) {         this.value = value;    }    public void assertValue() {        if (value != value) {            System.out.println("Magic");            Test.flag=false;        }    }}class HolderContainer {    public Holder holder;    public void init() {        holder = new Holder(42);      }}

I never got the program to evaluate value!=value to true.I don't think this proves anything and didn't run it for more than a couple minutes, but I hope this will be a better starting point for a well designed test or at least help to figure out some possible flaws in the tests.

I tried to insert a sleep between Test.hc=new HolderContainer(); and Test.hc.init();, between public Holder holder; and public void init() { and after public void init() {.

I am also concerned that checking if a value is null or catching the NullPoiterException may affect the timing too much.

Please note that the currently accepted answer to Improper publication of Java Object Reference says this problem is probably impossible under an x86 architecture. It may also be JVM dependent.

You are probably trying to simulate a concurrency scenario, which I believe is very hard to simulate using a couple of threads.

The following test-case which you have written is not correct at all is more likely to throw a NullPointerException.

public class Tests {  private HolderContainer hc = new HolderContainer();  class Initialization implements Runnable {    public void run() {      hc.init();    }  }  class Checking implements Runnable {    public void run() {      hc.holder.assertValue();    }  }  public void run() {    new Thread(new Initialization()).start();      new Thread(new Checking()).start();   }}

What if your Checking Thread executes before Initialization one??Also putting a sleep there simply means that executing thread will sleep and does tell you about the internal atomic operations being performed by then.

Did not reproduce it with your code. Here is an example to emulate un-safe publication. The strategy is let one thread publication Holder and let another check its value.

class Holder {    private volatile int value;    public Holder(int value, HolderContainer container) {        container.holder = this;  // publication this object when it is not initilized properly        try {            Thread.sleep(10);          } catch (Exception e) {        }        this.value = value; // set value    }    public int getValue() {        return value;    }}class HolderContainer {    public Holder holder;    public Holder getHolder() {         if (holder == null) {             holder = new Holder(42, this);        }        return holder;    }}public class Tests {    public static void main(String[] args) {        for (int loop = 0; loop < 1000; loop++) {            HolderContainer holderContainer = new HolderContainer();            new Thread(() -> holderContainer.getHolder()).start();            new Thread(() -> {                Holder holder = holderContainer.getHolder();                int value1 = holder.getValue();  // might get default value                try {                    Thread.sleep(10);                } catch (Exception e) {                }                int value2 = holder.getValue(); // might get custom value                if (value1 != value2) {                    System.out.println(value1 + "--->" + value2);                }            }).start();        }    }}