Reentrant Locks

Synchronized uses intrinsic locks or monitors. Every object in Java has an intrinsic lock associated with it. Whenever a thread tries to access a synchronized block or method, it acquires the intrinsic lock or the monitor on that object. In the case of static methods, the thread acquires the lock over the class object.

ReentrantLock is an explicit locking mechanism.  A reentrant mutual exclusion Lock with the same basic behavior and semantics as the implicit monitor lock accessed using synchronized methods and statements, but with following extended capabilities.

Polled and Timed Lock Acquisition

Lock.tryLock() is polled lock acquisition mechanism and tryLock(long timeout, TimeUnit unit) is timed lock acquisition mechanism. tryLock() will return immediately. If no other thread locked, then it will return true else returns false. The tryLock(long timeout, TimeUnit unit) will wait for the timeout period to acquire the lock if the lock is not available until timeout period it returns with false similar to tryLock(). In timed tryLock, when the current thread is waiting for timeout duration for acquiring the lock, meanwhile if another thread interrupts it, it will come out of lock acquisition by an InterruptedException. tryLock(long timeout, TimeUnit unit) behavior is same as lock.lockInterruptibly() for the duration of the timeout when it is waiting for the lock, ie., if another thread interrupts, it will come out lock acquisition attempt.

Interruptible Lock Acquisition

Lock.lockInterruptibly() is similar to lock() but it can be interrupted by another thread. The ReentrantLock.lock() is a blocking call in an attempt to acquire the lock, but lockInterruptibly() is non-blocking call, another thread can interrupt it from indefinitely waiting for acquiring the lock. In a way, ReentrantLock.lock() is same as the implicitly synchronized lock.

Non-block Structured Locking

The synchronized block (intrinsic lock) must be fully contained within a single method. A Lock can have it’s calls to lock() and unlock() in separate methods. In intrinsic locks, acquire-release pairs are block-structured. In other words, a lock is always released in the same basic block in which it was acquired, regardless of how control exits the block. Extrinsic locks allow the facility to have more explicit control.

Fairness

The ReentrantLock constructor offers a choice of two fairness options: create a non-fair lock or a fair lock. With fair locking, threads can acquire locks only in the order in which they were requested, whereas an unfair lock allows a lock to acquire it out of its turn. This is called barging.

The ReentrantLock has following four methods to acquire the lock.

lock() : this un-interruptible similar to intrinsic locking mechanism provided by synchronized methods or blocks. The uninterruptible lock will block when lock.lock() gets called until the thread that currently owns the lock releases it. If the thread that currently owns the lock never releases it then this thread can't get the lock and will be blocked forever. This is analogous to the normal operation of the synchronized (object) { } block. The method will block while trying to get a lock on the object when it does it proceeds.

tryLock() : this is polled mechanism and non-blocking call. It checks if the lock is available, and if not available immediately returns with false and proceeds.

tryLock(long timeout, TimeUnit unit) : this is interruptible method. If the lock is not available, then it will wait for timeout duration to get the lock, meanwhile, if some other thread interrupts, it will come out of lock acquisition mechanism by InterruptedException and will not proceed like tryLock().

lockInterruptibly() : this is also interruptible method similar to tryLock(long timeout, TimeUnit unit) but without timeout.

In addition to above methods, the ReentrantLock has several other methods to see the number of threads waiting to acquire this lock and to query the number of holds on this lock by the current thread etc.,