Page History

Wiki MarkupStarting and using background threads during class initialization can result in class initialization cycles and deadlock. For example, the main thread responsible for performing class initialization can block waiting for the background thread, which in turn will wait for the main thread to finish class initialization. This issue can arise, for example, when a database connection is established in a background thread during class initialization \ [[Bloch 05b|AA. Java References#Bloch 05b]\]. Bloch 2005b]. Consequently, programs must ensure that class initialization is complete before starting any threads.

Noncompliant Code Example (Background Thread)

In this noncompliant code example, the static initializer starts a background thread as part of class initialization. The background thread attempts to initialize a database connection but needs to should wait until all members of the ConnectionFactory class, including dbConnection, have been are initialized.

public final class ConnectionFactory {
  private static Connection dbConnection;
  // Other fields ...
	  
  static {
    Thread dbInitializerThread = new Thread(new Runnable() {
        @Override public void run() {
          // Initialize the database connection
          try {
            dbConnection = DriverManager.getConnection("connection string");	
  
        } catch (SQLException e) {
            dbConnection = null;	
          }
        }
    });

    // Other initialization, for example, start other threads   
	    
    dbInitializerThread.start();
    try {
      dbInitializerThread.join();
    } catch (InterruptedException ie) {
      throw new AssertionError(ie);
    }
  }
	  
  public static Connection getConnection() {
    if (dbConnection == null) {
      throw new IllegalStateException("Error initializing connection");  
    }
    return dbConnection;
  }
	  
  public static void main(String[] args) {
    // ...
    Connection connection = getConnection();
  }
}

...

Statically initialized fields are guaranteed to be fully constructed before they are made visible to other threads (see [CON28TSM03-J. Do not publish partially initialized objects] for more information). Consequently, the background thread must wait for the main (or foreground) thread to finish initialization before it can proceed. However, the {{ConnectionFactory}} class's main thread invokes the {{join()}} method , which waits for the background thread to finish. This interdependency causes a class initialization cycle that results in a deadlock situation \[ [Bloch 05b|AA. Java References#Bloch 05b]\2005b].

Similarly, it is inappropriate to start threads from constructors (see CON16TSM01-J. Do not let the ( this ) reference escape during object construction for more information). Creating timers that perform recurring tasks and starting those timers from within code responsible for initialization also creates introduces liveness issues.

Compliant Solution (

...

Static Initializer, No Background Threads)

This compliant solution does not spawn any initializes all fields on the main thread rather than spawning background threads from the static initializer. Instead, all fields are initialized in the main thread.

public final class ConnectionFactory {
  private static Connection dbConnection;
  // Other fields ...

  static {
    // Initialize a database connection
    try {
      dbConnection = DriverManager.getConnection("connection string");
    } catch (SQLException e) {
      dbConnection = null;	
    }        
    // Other initialization (do not start any threads)
  }

  // ...
}

Compliant Solution (ThreadLocal)

This compliant solution initializes the database connection from a ThreadLocal object so that every each thread can obtain its own unique instance of the connection.

public final class ConnectionFactory {
  private static final ThreadLocal<Connection> connectionHolder
                       = new ThreadLocal<Connection>() {
   @Override   public Connection initialValue() {
     try {
      try {
Connection dbConnection =
        Connection dbConnection = DriverManager.getConnection("connection string");
          return dbConnection;
        } catch (SQLException e) {
          return null;
        }
      }
    };

  // Other fields ...

  static {
    // Other initialization (do not start any threads)
  }
    
  public static Connection getConnection() {
    Connection connection = connectionHolder.get();
    if (connection == null) {
      throw new IllegalStateException("Error initializing connection");  
    }
    return connection;
  }

  public static void main(String[] args) {
    // ...
    Connection connection = getConnection();
  }
}

The static initializer can be used to initialize any other shared , class fieldsfield. Alternatively, the fields can be initialized from the initialValue() method.

Exceptions

public final class ObjectPreserver implements Runnable {
  private static final ObjectPreserver lifeLine = new ObjectPreserver();

  private ObjectPreserver() {
    Thread thread = new Thread(this);
    thread.setDaemon(true);
    thread.start(); // Keep this object alive
  }
 
  // Neither this class nor HashMap will be garbage-collected.
  // References from HashMap to other objects
  // will also exhibit this property
  private static final ConcurrentHashMap<Integer,Object> protectedMap
  
    = new ConcurrentHashMap<Integer,Object>();
  
  public synchronized void run() {
    try {
      wait();
    } catch (InterruptedException e) { 
      Thread.currentThread().interrupt(); // Reset interrupted status 
    }
  }

  // Objects passed to this method will be preserved until
  // the unpreserveObject() method is called
  public static void preserveObject(Object obj) {    
    protectedMap.put(0, obj);  
  }
  
  // Returns the same instance every time
  public static Object getObject() {
    return protectedMap.get(0);	  
  }
  
  // Unprotect the objects so that they can be garbage-collected
  public static void unpreserveObject() {
    protectedMap.remove(0);
  }
}

This is a singleton class . (See MSC16see MSC07-J. Address the shortcomings of the Singleton design patternPrevent multiple instantiations of singleton objects for more information on how to defensively code singleton classes). ) The initialization involves creating a background thread using the current instance of the class. The thread waits indefinitely by invoking Object.wait(). Consequently, this object exists persists for the remainder of the Java Virtual Machine's (JVM's) lifetime. Because the object is managed by a daemon thread, the thread does not hinder a cannot interfere with normal shutdown of the JVM.

While Although the initialization does involve involves a background thread, the thread does not access any fields or create that thread neither accesses fields nor creates any liveness or safety issues. Consequently, this code is a safe and useful exception to this guidelinerule.

Risk Assessment

Starting and using background threads during class initialization can result in deadlock conditions.

Related Vulnerabilities

Any vulnerabilities resulting from the violation of this rule are listed on the CERT website.

References

...

Automated Detection

Bibliography

Issue Tracking

||Completed||Priority||Locked||CreatedDate||CompletedDate||Assignee||Name||
|T|M|F|1269649993019|1269700561582|rcs_mgr|"Starting and using background threads during class initialization can result in class initialization cycles and deadlock. *For instance,* the main thread responsible for performing class initialization *may* block waiting for the background thread, which in turn will wait for the main thread to finish class initialization." ... see suggested words in bold...I am also generally unsure about the use of "can" vs. "may" because deadlocks are a "possibility" so perhaps "may" should be used?|

...

CON08-J. Do not synchronize on objects that may be reused      11. Concurrency (CON)      CON07-J. Use private final lock objects to synchronize classes that may interact with untrusted codeImage Added Image Added Image Added