Page History

Static shared data should not be protected using instance locks because the instance locks these are ineffective when two or more instances of the class are created. Consequently, the shared state is not safe for concurrent access unless a static lock object is used. IdeallyIf the class can interact with untrusted code, the lock should must also be private and final, as per CON04-J. Use private final lock objects to synchronize classes that may interact with untrusted code.

Noncompliant Code Example (

...

Non-static

...

Lock Object for Static Data)

This noncompliant code example uses a non-static lock object to guard access to a static field counter. If two Runnable tasks are started, they will create two instances of the lock object and lock on each separately.

...

This does not prevent either thread from observing an inconsistent value of counter because the increment operation on volatile fields is not atomic in the absence of proper synchronization (see CON01-J. Ensure that compound operations on shared variables are atomic).

Noncompliant Code Example (

...

Method Synchronization for Static Data)

This noncompliant code example uses method synchronization to protect access to a static class field counter.

public final class CountBoxes implements Runnable {
  private static volatile int counter;
  // ...

  public synchronized void run() {
    counter++; 
    // ... 
  }
  // ...
}

In this case, the intrinsic lock is associated with each instance of the class and not with the class itself. Consequently, threads constructed using different Runnable instances may observe inconsistent values of the counter.

Compliant Solution (

...

Static Lock Object)

This compliant solution declares the lock object as static and consequently, ensures the atomicity of the increment operation.

public class CountBoxes implements Runnable {
  private static int counter;
  // ...
  private static final Object lock = new Object();    
  
  public void run() {
    synchronized(lock) {
      counter++; 
      // ...
  }
  // ...
}

There is no requirement for declaring need to declare the counter variable as volatile when synchronization is used.

...

Using an instance lock to protect static shared data does not provide any synchronization properties and can lead to can result in non-deterministic behavior.

...