Page History

class Base {
  public void doSomething() 

{quote}
A class method that is declared {{synchronized}} synchronizes on the lock associated with the {{Class}} object of the class.
{quote}

This does not mean that a subclass using {{getClass()}} can only synchronize on the {{Class}} object of the base class. In fact, it will lock on its own {{Class}} object, which may or may not be what the programmer had in mind. The intent should be clearly documented or annotated. Note that if a subclass does not override an accessible noncompliant superclass's method, it inherits the method which may lead to the false conclusion that the superclass's intrinsic lock is available in the subclass.


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

In this noncompliant code example, the {{parse()}} method of class {{Base}} parses a date and synchronizes on the class object returned by {{getClass()}}. The class {{Derived}} also inherits the {{parse()}} method. However, this inherited method synchronizes on the class object of {{Derived}} because of the particular return value of {{getClass()}}. 

{{Derived}} also adds a method {{doSomethingAndParse()}} that locks on the class object of the base class because the developer misconstrued that the {{parse()}} method in {{Base}} always obtains a lock on the {{Base}} class object, and {{doSomethingAndParse()}} must follow the same locking policy. Consequently, the class {{Derived}} has two different locking strategies and is not thread-safe.

{code:bgColor=#FFcccc}
class Base {
  static DateFormat FORMAT =
    DateFormat.getDateInstance(DateFormat.MEDIUM);
	  
  public Date parse(String str) throws ParseException {
    synchronized (getClass()) {
      //return ... FORMAT.parse(str);
    }
  }
}

class Derived extends Base {
  public Date doSomethingAndParse(String str) throws ParseException {	  
    synchronized(Base getBase(); {
    // ...
  }

 .class) {
      return FORMAT.parse(str); 
    }
  }
}
{code}

{mc}
// Hidden main() method to be put in class Derived
// Prints arbitrary date values and throws exceptions at times

public static void main(String[] args) {
  for(int i = 0; i < 100; i++) {
    new Thread(new Runnable() {
      @Override public void doSomethingElserun() {	    	 
    Base   obj = getBase();try {
  	  obj.doSomething(); 
  }
}

class Base {
  public void doSomething()System.out.println(new Derived().parse("Jan 1, 2010"));
	} catch (ParseException e) {
	  // Forward to handler
	}
      }
    }).start();
        
    new Thread(new Runnable() {
      @Override public void run() {
         try {
    	   System.out.println(new Derived().doSomethingAndParse("Jan 2, 2010"));
	 } catch (ParseException e) {
	  // Forward to handler
	 }
      }
    }).start();	   
  }  
}
{mc}


h2. Compliant Solution (class name qualification)

Explicitly define the name of the class through name qualification ({{Base}} in this compliant solution) in the synchronized block. 

{code:bgColor=#ccccff}
class Base {
  static DateFormat FORMAT =
    DateFormat.getDateInstance(DateFormat.MEDIUM);
	  
  public Date parse(String str) throws ParseException {
    synchronized (Base.class) {
      //return ... FORMAT.parse(str);
    }
  }
}

// ...
{code}

This code example always synchronizes on the {{Base.class}} object, even if it is called from a {{Derived}} object.

The class object that is being used for synchronization should not be accessible to untrusted code. If the class is package-private, callers from other packages may not access the class object, ensuring its trustworthiness as an intrinsic lock object. For more information, see [CON04-J. Synchronize using an internal private final lock object].


h2. Compliant Solution ({{Class.forName()}})

This compliant solution uses the {{Class.forName()}} method to synchronize on the {{Base}} class's {{Class}} object.

{code:bgColor=#ccccff}
class Base {
  static DateFormat FORMAT =
    DateFormat.getDateInstance(DateFormat.MEDIUM);
	  
  public voidDate doSomethingparse(String str) throws ParseException {
    synchronized (Class.forName("Base")) {
      //return ... FORMAT.parse(str);
    }
  }
}