Java Concurrency - Lock Objects (java.util.concurrent.locks)

> Procedural Languages > Java > Java - Concurrency (Parallel Work)

1 - About

Lock Object package is a High Level Concurrency of the java.util.concurrent. For low-level, intrinsic lock (monitor), see Java Concurrency - (Intrinsic|Monitor|Implicit) Lock or Monitor.


3 - Property

  • As with implicit locks, only one thread can own a Lock object at a time.
  • Lock objects also support a wait/notify mechanism, through their associated Condition objects.

4 - Advantage

4.1 - Back out

The biggest advantage of Lock objects over implicit locks is their ability to back out of an attempt to acquire a lock.

The tryLock method backs out:

  • if the lock is not available immediately
  • or before a timeout expires (if specified).

The lockInterruptibly method backs out:

  • if another thread sends an interrupt before the lock is acquired.

4.2 - "hand-over-hand" or "chain locking"

The use of synchronized methods or statements provides access to the implicit monitor lock associated with every object, but forces all lock acquisition and release to occur in a block-structured way: when multiple locks are acquired they must be released

  • in the opposite order,
  • in the same lexical scope in which they were acquired.

There are occasions where you need to work with locks in a more flexible way. For example, some algorithms for traversing concurrently accessed data structures require the use of “hand-over-hand” or “chain locking”: you acquire the lock of node A, then node B, then release A and acquire C, then release B and acquire D and so on. Implementations of the Lock interface enable the use of such techniques by allowing a lock to be acquired and released in different scopes, and allowing multiple locks to be acquired and released in any order.