Page History

 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|AA. Java References#Pugh 08]\]- {mc} probably incorrect after splitting{mc}. It is important to recognize the entities with whom synchronization is required rather than indiscreetly scavenging for objects to synchronize on. {color:red}we need a more precise statement about what specifically this guideline requires{color} {mc} any suggestions? {mc}  {mc} not yet {mc} 

h2. Noncompliant Code Example ({{Boolean}} lock object)

This noncompliant code example synchronizes on a {{Boolean}} lock object. 

{code:bgColor=#FFcccc}
private final Boolean initialized = Boolean.FALSE;

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

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.


h2. Noncompliant Code Example (boxed primitive)

This noncompliant code example locks on a boxed {{Integer}} object.

{code:bgColor=#FFcccc}
int lock

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

public void doSomething() {
  synchronized (Lock) {
    count++;
    // ...
  }
}
{code}

private int count 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. 


h2. 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}}.

{code:bgColor=#ccccff}
int lock = 0;
private final Integer Lock = new Integer(lockcount); 

public void doSomething() {
  synchronized (Lock) {
    count++;
    // ...
  }
}
{code}

 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.


h2. Noncompliant Code Example (interned {{String}} object)

This noncompliant code example locks on an interned {{String}} object.

{code:bgColor=#FFcccc}
private final String _lock = new String("LOCK").intern();

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

According to the Java API \[[API 06|AA. Java References#API 06]\], class {{

 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]).

h2. Noncompliant Code Example ({{String}} literal)

This noncompliant code example locks on a final {{String}} literal.

{code:bgColor=#FFcccc}
// This bug was found in jetty-6.1.3 BoundedThreadPool
private final String _lock = "LOCK";

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

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


h2. Compliant Solution ({{String}} instance)

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

{code:

bgColor=#ccccff}
private final String _lock = new String("LOCK");

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

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.

h2. 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.

{code:bgColor=#ccccff}
private final Object lock = new Object();

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

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

h2. Risk Assessment

Synchronizing on objects that may be reused may result in deadlocks and non-deterministic behavior. 

|| Rule || Severity || Likelihood || Remediation Cost || Priority || Level ||
| CON02- J | medium | probable | medium | {color:#cc9900}{*}P8{*}{color} | {color:#cc9900}{*}L2{*}{color} |


h3. Automated Detection

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

||Noncompliant Code Example||Flagged||Checker||Message||
|{{Boolean}} lock object|Yes|DL_SYNCHRONIZATION_ON_BOOLEAN|Synchronization on Boolean could deadlock|
|Boxed primitive|Yes|