CON02-J. Do not synchronize on objects that may be reused

Misuse of synchronization primitives is a common source of concurrency issues. A significant number of concurrency vulnerabilities arise from locking on the wrong kind of object. An analysis of the JDK 1.6.0 source code discovered 31 bugs that fell into this category [[Pugh 08]]

. It is important to recognize the entities with whom synchronization is required rather than indiscreetly scavenging for objects to synchronize on. we need a more precise statement about what specifically this guideline requires

Noncompliant Code Example (Boolean lock object)

This noncompliant code example synchronizes on a Boolean lock object.

private final Boolean initialized = Boolean.FALSE;

public void doSomething() {
  synchronized(initialized) { 
    // ...
  }
}

The Boolean type is unsuitable for locking purposes because it allows only two values: TRUE and FALSE. Boolean literals containing the same value share unique instances of class Boolean in the JVM. In this example, initialized references the instance corresponding to the value FALSE. If any other code inadvertently synchronizes on a Boolean literal with the value FALSE, the lock instance is reused and the system may become unresponsiveness or deadlock.

Noncompliant Code Example (boxed primitive)

This noncompliant code example locks on a boxed Integer object.

int lock = 0;
private final Integer Lock = lock; // Boxed primitive Lock is shared

public void doSomething() {
  synchronized(Lock) { 
    // ...
  }
}

Boxed types may use the same instance for a range of integer values and consequently suffer from the same problem as Boolean constants. If the value of the primitive can be represented as a byte, the wrapper object is reused. Note that the use of the boxed Integer wrapper object is insecure; instances of the Integer object constructed using the new operator (new Integer(value)) are unique and not reused. In general, holding a lock on any data type that contains a boxed value is insecure.

Compliant Solution (Integer)

This compliant solution recommends locking on a non-boxed Integer. The doSomething() method synchronizes using the intrinsic lock of the Integer instance, Lock.

int lock = 0;
private final Integer Lock = new Integer(lock); 

public void doSomething() {
  synchronized(Lock) { 
    // ...
  }
}

When explicitly constructed, an Integer object has a unique reference and its own intrinsic lock that is not shared with other Integer objects or boxed integers having the same value. While this is an acceptable solution, it may cause maintenance problems because developers might incorrectly assume that boxed integers are appropriate lock objects. A more appropriate solution is to synchronize on an internal private final lock Object as described in the following compliant solution.

Noncompliant Code Example (interned String object)

This noncompliant code example locks on an interned String object.

private final String _lock = new String("LOCK").intern();

public void doSomething() {
  synchronized(_lock) {
    // ...
  }
}

According to the Java API [[API 06]], class java.lang.String documentation:

When the intern() method is invoked, if the pool already contains a string equal to this String object as determined by the equals(Object) method, then the string from the pool is returned. Otherwise, this String object is added to the pool and a reference to this String object is returned.

Consequently, an interned String object behaves like a global variable in the Java Virtual Machine (JVM). As demonstrated in this noncompliant code example, even if every instance of an object maintains its own field lock, the field references a common String constant. Locking on String constants has the same problem as locking Boolean constants.

Additionally, hostile code from any other package can exploit this vulnerability if the class is accessible (see [CON04-J. Synchronize using an internal private final lock object]).

Noncompliant Code Example (String literal)

This noncompliant code example locks on a final String literal.

// This bug was found in jetty-6.1.3 BoundedThreadPool
private final String _lock = "LOCK";

// ...
  synchronized(_lock) { 
    // ...
  }
// ...

A String literal is a constant and is interned. Consequently, it suffers from the same pitfalls as the preceding noncompliant code example.

Compliant Solution (String instance)

This compliant solution locks on a String instance that is not interned.

private final String _lock = new String("LOCK");

public void doSomething() {
  synchronized(_lock) {
    // ...
  }
}

A String instance differs from a String literal. The instance has a unique reference and its own intrinsic lock that is not shared by other string object instances or literals. A better approach is to synchronize on an internal private final lock object as shown in the following compliant solution.

Compliant Solution (internal private final lock Object)

This compliant solution synchronizes on an internal private final lock object. This is one of the few cases where a java.lang.Object instance is useful.

private final Object lock = new Object();

public void doSomething() {
  synchronized(lock) {
    // ...
  }
}

For more information on using an Object as a lock, see [CON04-J. Synchronize using an internal private final lock object].

Risk Assessment

Synchronizing on an inappropriate object can provide a false sense of thread safety and result in non-deterministic behavior.

Automated Detection

The following table summarizes the examples flagged as violations by FindBugs:

The following table summarizes the examples flagged as violations by SureLogic Flashlight:

Related Vulnerabilities

Search for vulnerabilities resulting from the violation of this rule on the CERT website.

References

[[API 06]] Class String, Collections
[[Findbugs 08]].
[[Pugh 08]] "Synchronization"
[[Miller 09]] Locking
[[Tutorials 08]] Wrapper Implementations

[!The CERT Sun Microsystems Secure Coding Standard for Java^button_arrow_left.png!]      [!The CERT Sun Microsystems Secure Coding Standard for Java^button_arrow_up.png!]      [!The CERT Sun Microsystems Secure Coding Standard for Java^button_arrow_right.png!]