Race Condition: Class Initialization Cycle

Assigning a static field to a new object calls the constructor even if it is dependent on other variables initialization, which may lead to objects being initialized incorrectly.

When a Java class is initialized, it calls the initializers for static fields declared in the class prior to the class constructor. This means that a constructor assigned to this will be called prior to other code, and if this constructor is then dependent on other fields or variables being initialized, it may lead to partially initialized objects, or objects initialized with incorrect values.

Example 1: The following class declares a static field and assigns it to a new object.

  ...
  public class Box{
    public int area;
    public static final int width = 10;
    public static final Box box = new Box();
    public static final int height = (int) (Math.random() * 100);

    public Box(){
        area = width * height;
    }
    ...
  }
  ...

In Example 1, the developer would expect that box.area would be a random integer that happens to be a multiple of 10, due to width being equal to 10. In reality however, this will always have a hardcoded value of 0. Static final fields declared with a compile-time constant are initialized first, and then each one is executed in order. This means that since height is not a compile-time constant, it is declared after the declaration of box, and therefore the constructor is called prior to the field height being initialized.

Example 2: The following classes declare static fields that rely on each other.

  ...
  class Foo{
    public static final int f = Bar.b - 1;
    ...
  }
  ...
  class Bar{
    public static final int b = Foo.f + 1;
    ...
  }

This example is perhaps easier to identify, but would be dependent on which class is loaded first by the JVM. In this example Foo.f could be either -1 or 0, and Bar.b could be either 0 or 1.