Page History

 concurrent access.

h2. 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, each consisting of a thread are started, they will create two instances of the lock object and lock on each separately. 

{mc} Do not declare the classes non-public and final, otherwise threads will be unable access counter {mc}

{code:bgColor=#FFcccc}
public class CountBoxes implements Runnable {
  static volatile int counter;
  // ...

  private final Object lock = new Object();    

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

  public static void main(String[] args) {
    Runnable r1 = new CountBoxes();
    Thread t1 = new Thread(r1);
    Runnable r2 = new CountBoxes();
    Thread t2 = new Thread(r2);
    t1.start();
    t2.start();
  }
}
{code}

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

. 


h2. Noncompliant Code Example (method synchronization for {{static}} data)

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

{code:bgColor=#FFcccc}
public class CountBoxes implements Runnable {
  static volatile int counter;
  // ...

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

The problem is that this lock is associated with each instance of the class and not with the class object itself. Consequently, threads constructed using different {{Runnable}} instances may observe inconsistent values of the {{counter

}}.


h2. Compliant Solution ({{static}} lock object)

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

{code:bgColor=#ccccff}
public class CountBoxes implements Runnable {
  static int counter;
  // ...

  private static final Object lock = new Object();    
  
  public void run() {
    synchronized(lock) {
      counter++; 
      // ...
  }
  // ...
}
{code}

There is no requirement of declaring the {{counter}} variable as {{volatile}} when synchronization is used.

h2.