Page History

{quote}
A {{ReentrantLock}} is owned by the thread last successfully locking, but not yet unlocking it. A thread invoking {{lock}} will return, successfully acquiring the lock, when the lock is not owned by another thread.
{quote}

This means that an unreleased lock in any thread will stop other threads from acquiring the same lock. 


h2. Noncompliant Code Example (checked exception)

This noncompliant code example protects a resource by using a {{ReentrantLock}} but fails to release the lock on an exceptional condition. Control flow transfers to the {{catch}} block and the call to {{unlock()}} does not execute.

{code:bgColor=#FFcccc}
public void doSomething(File file) {
  final Lock lock = new ReentrantLock();
  try {
    lock.lock();
    InputStream in = new FileInputStream( file);
    // Do something with the open file.
    lock.unlock();
  } catch(FileNotFoundException fnf) {
    // Handle the exception
  }
}
{code}

Note that the lock is not released even when the {{doSomething()}} method returns

. 


h2. Compliant Solution

This compliant solution uses a {{try}}-{{finally}} block immediately after acquiring the lock. This ensures that the lock is appropriately released even in the event of an exceptional condition. Also, the lock is acquired outside the try block, which guarantees that the lock is held when the finally block executes.

{code:bgColor=#ccccff}
public void doSomething(File file) {
  final Lock lock = new ReentrantLock();
  lock.lock();
  try {
    InputStream in = new FileInputStream( file);
    // Do something with the open file.
  } catch(FileNotFoundException fnf) {
    // Handle the exception
  } finally {
    lock.unlock();
  }
}

{code}


h2. Noncompliant Code Example (unchecked exception)

This noncompliant code example uses a {{ReentrantLock}} to protect a {{java.util.Date}} instance, which is not thread-safe by design. It also needs to catch {{Throwable}} to be compliant with [EXC06-J. Do not allow exceptions to transmit sensitive information]. 

{mc} Do not declare lock as private as it need package-wide accessibility for illustrative purposes {mc}

{code:bgColor=#FFcccc}
final class DateHandler {
  private final Date date = new Date();
  final Lock lock = new ReentrantLock();

  public void doSomethingSafely(String str) {
    try {
      doSomething(str);
    } catch(Throwable t) {
      // Forward to handler
    }
  }

  public void doSomething(String str) {
    lock.lock();
    String dateString = date.toString();
    if (str.equals(dateString)) {
      // ...
    }
    lock.unlock();
  }
}
{code}

However, because the {{doSomething()}} method does not check whether {{str}} is {{null}}, a runtime exception in this component may prevent the lock from being released.


h2.

 

{code:bgColor=#ccccff}
final class DateHandler {
  private final Date date = new Date();
  final Lock lock = new ReentrantLock();

  public void doSomethingSafely(String str) {
    try {
      doSomething(str);
    } catch(Throwable t) {
      // Forward to handler
    }
  }

  public void doSomething(String str) {
    try {
      lock.lock();
      String dateString = date.toString();
      if (str.equals(dateString)) {
        // ...
      }
    } finally {
      lock.unlock();
    }
  }
}
{code}

Consequently, the lock is released successfully even in the event of a runtime exception