Page History

public class Helper {
  private intHelper nhelper;

  public Helper getHelper(int n) {
    this.n = nreturn helper;
  }

  public  // other fields & methods
}


class Foovoid initialize() {
    helper = new Helper(42);
  }
}

public class Helper {
  private Helperint helpern;

  public Helper(int getHelper(n) {return
 helper;}

  public void initialize() {this.n = n;
  }

  helper = new Helper(42);
  }
}

// ...
}


{code}

Suppose two threads have access to the same {{Foo}} object through the use of the {{getHelper()}} method, and {{initialize()}} has not been called yet. Both threads will see the {{helper}} field as uninitialized. Subsequently, if one thread calls {{initialize()}}, and the other calls {{getHelper()}}, the second thread may either see the {{helper}} reference as {{null}}, observe a fully-initialized {{Helper}} object with the {{n}} field set to 42, or observe a partially-initialized {{Helper}} object with an uninitialized {{n}} (default value of {{n}} being {{0}}).

In particular, the JMM permits compilers to allocate memory for the new {{Helper}} object and assign it to the {{helper}} field before initializing it. This introduces a race window during which other threads may see a partially-initialized {{helper}} object.

h2. Compliant Solution ({{volatile}})

If the {{helper}} field is declared as {{volatile}}, it is guaranteed to be fully constructed (properly initialized) before the reference is made visible.

{code:bgColor=#CCCCFF}
class Foo {
  private volatile Helper helper;

  public Helper getHelper() {
    return helper;
  }

  public void initialize() {
    helper = new Helper(42);
  }
}

{code}


h2. Compliant Solution ({{final}})

If the {{helper}} field is declared as {{final}}, then it is guaranteed to be fully constructed before the reference is made visible.

{code:bgColor=#CCCCFF}
class Foo {
  private final Helper helper;

  public Helper getHelper() {
    return helper;
  }

  public void initialize() {
    helper = new Helper(42);
  }
}

{code}

However, this disallows setting the {{helper}} field to a new object.


h2. Compliant Solution ({{immutable}})

If the {{Helper}} class is [immutable|BB. Definitions#immutable], it is guaranteed to be fully constructed before its reference is made visible. The {{Helper}} object must be truly immutable; it is not sufficient for the program to refrain from modifying the object.

{code:bgColor=#CCCCFF}
public class Helper {
  private final int n;

  public Helper(int n) {
    this.n = n;
  }

  // other fields & methods, all fields are final
}

...
}
{code}

Note that if the {{Helper}} object was mutable, in addition to the problem of visibility of a reference to a partially-constructed object, another problem would ensue. The state of the object may be modified after its construction and publication, causing subtle thread-safety issues. For more information see [CON11-J. Do not assume that declaring an object volatile guarantees visibility of its members].


h2. Compliant Solution ({{synchronized}})

The reference of a partially-constructed object can be prevented from being made visible by using method synchronization.

{code:bgColor=#CCCCFF}
class Foo {
  private Helper helper;

  public synchronized Helper getHelper() {
    return helper;
  }

  public synchronized void initialize() {
    helper = new Helper(42);
  }
}
{code}

Synchronizing both methods guarantees that they will never run simultaneously in different threads. If one

}} method will always finish first, fully initializing the {{Helper}} object on its way. This forbids {{getHelper()}} from retrieving a {{Helper}} object that is partially initialized. 


h2. Compliant Solution (thread-safe composition)

Some collection classes provide thread-safety of accesses to contained elements. If the {{helper}} field is contained in such a collection, the {{Helper}} object is guaranteed to be fully constructed before its reference is made visible. This compliant solution encases the {{helper}} field in a {{Vector}}.

{code:bgColor=#CCCCFF}
class Foo {
  private Vector<Helper> helper;

  public Helper getHelper() {
    return helper.elementAt(0);
  }

  public void initialize() {
    helper = new Vector<Helper>();
    helper.add(new Helper(42));
  }
}

 before its reference is made visible. {mc} cite JLS section here {mc}

{code:bgColor=#CCCCFF}
class Foo {
  private static Helper helper = new Helper(42);

  public static Helper getHelper() {
    return helper;
  } 
}
{code}