# V6082. Unsafe double-checked locking.

The analyzer has detected a potential error related to unsafe use of the double-checked locking pattern.

Double-checked locking is a pattern used to reduce the overhead of acquiring a lock. The locking condition is first checked without synchronization. And only if the condition is true, the thread attempts to acquire the lock. Thus, locking occurs only when it is indeed necessary.

The most common mistake when implementing this pattern is publishing an object before initializing it:

    class TestClass
    {
      private static volatile Singleton singleton;

      public static Singleton getSingleton()
      {
        if (singleton == null)
        {
          synchronized (TestClass.class)
          {
            if (singleton == null)
            {
              singleton = new Singleton();
              singleton.initialize();          // <=
            }
          }
        }
        return singleton;
      }
    }

In a multi-threaded environment, one of the threads could see an already created object and use it even if that object has not been initialized yet.

A similar issue might occur when the object is reassigned in the synchronized block depending on some conditions. Some other thread may well start working with the object after its first assignment without knowing that some other object is meant to be used further in the program.

Such errors are fixed by using a temporary variable:

    class TestClass
    {
      private static volatile Singleton singleton;

      public static Singleton getSingleton()
      {
        if (singleton == null)
        {
          synchronized (TestClass.class)
          {
            if (singleton == null)
            {
              Singleton temp = new Singleton();
              temp.initialize();
              singleton = temp;
            }
          }
        }
        return singleton;
      }
    }

Another common mistake when implementing this pattern is skipping the 'volatile' modifier when declaring the field being accessed:

    class TestClass
    {
      private static Singleton singleton;

      public static Singleton getSingleton()
      {
        if (singleton == null)
        {
          synchronized (TestClass.class)
          {
            if (singleton == null)
            {
              Singleton temp = new Singleton();
              temp.initialize();
              singleton = temp;
            }
          }
        }
        return singleton;
      }
    }

An object of class 'Singleton' could be created several times because the 'singleton == null' check could see the value 'null' cached in the thread. Besides, the compiler could alter the order of operations over non-volatile fields and, for example, swap the call to the object initialization method and the storing of the reference to that object in the field, thus resulting in using the object, which is yet to be initialized.

One of the reasons why such errors are dangerous is that the program will run correctly in most cases. In this particular case, the incorrect behavior may manifest itself depending on the JVM version, concurrency level, thread scheduler's decisions, and other factors. Such complex conditions are extremely difficult to reproduce manually.

This diagnostic is classified as:

CWE-609 CERT-LCK10-J

You can look at examples of errors detected by the V6082 diagnostic.