Page History

Overriding thread-safe methods with methods that are not thread-safe can result in improper synchronization, if the client inadvertently operates on an instance of the subclass. An overridden synchronized method's contract may can be violated, if a subclass provides an implementation that is not safe for concurrent use.

Overriding thread-safe methods with methods that are not thread-safe is not, in itself, an error, but . However. it is disallowed by this guideline, because it may easily result in errors that are otherwise difficult to diagnose.

The locking strategy of classes designed for inheritance should always be documented. This information can subsequently be used to determine an appropriate locking strategy for subclasses (see CON04-J. Use private final lock objects to synchronize classes that may interact with untrusted code).

Noncompliant Code Example (

...

Synchronized Method)

This noncompliant code example overrides the synchronized doSomething() method in the Base class Base with an unsynchronized method in the derived Derived class Derived.

class Base {
  public synchronized void doSomething() {
    // ...	
  }
}

class Derived extends Base {
  public void doSomething() {
    // ...		
  }
}

The doSomething() method of the Base class Base can be safely used by multiple threads. However, but instances of the Derived subclass Derived cannot be safely used by multiple threads.

This programming error can be difficult to diagnose, because threads that accept instances of Base can also accept instances of its subclasses. Consequently, clients may could be unaware that they are operating on an instance of the subclass of a thread-safe class that is not in fact thread-safe.

Compliant Solution (

...

Synchronized Method)

This compliant solution synchronizes the doSomething() method of the subclass.

...

This compliant solution does not violate CON04-J. Use private final lock objects to synchronize classes that may interact with untrusted code, because the accessibility of the class is package-private which . That type of accessibility is allowable when untrusted code cannot infiltrate the package.

Compliant Solution (

...

Private Final Lock Object)

This compliant solution ensures that the Derived class is thread-safe by overriding the synchronized doSomething() method of the Base class with a method that synchronizes on a private final lock object.

...

This is an acceptable solution, provided that the Derived class has a consistent locking policy.

Noncompliant Code Example (

...

Private Lock)

This noncompliant code example defines a doSomething() method in the Base class Base that uses a private final lock, in accordance with CON04-J. Use private final lock objects to synchronize classes that may interact with untrusted code.

class Base {
  private final Object lock = new Object();

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

class Derived extends Base {
  public void doSomething() {
    try {
      super.doSomething();
    } finally {
      logger.log(Level.FINE, "Did something"); 
    }
  }
}

It is possible that for multiple threads may to cause the entries to be logged in an order that differs from the order in which the tasks are performed. Consequently, The the doSomething() method of the Derived class Derived cannot be used safely used by multiple threads, because it is not thread-safe.

Compliant Solution (

...

Private Lock)

This compliant solution synchronizes the doSomething() method of the subclass using a private final lock object.

class Base {
  private final Object lock = new Object();

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

class Derived extends Base {
  private final Object lock = new Object();

  public void doSomething() {
    synchronized (lock) {
      try {
        super.doSomething();
      } finally {
        logger.log(Level.FINE, "Did something"); 
      }
    }
  }
}

Note that the objects of Base and Derived objects maintain distinct locks that are inaccessible from each others' classes. Consequently, Derived can provide thread-safety guarantees independent of Base.

...

TODO

Related Vulnerabilities

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

References

...