Locks

The java.util.concurrent.locks.Lock interface provides more flexible and sophisticated locking operations than the synchronized keyword. It supports non-blocking lock attempts, lock timeouts, and lock interruptibility.

Lock vs. Synchronized

Let's compare:

• Explicit Release: Lock requires calling unlock() manually (typically inside a finally block). Synchronized releases locks automatically on scope exit.
• Non-blocking Attempt: tryLock() attempts lock acquisition immediately and returns a boolean without blocking.
• Fairness: ReentrantLock supports a fairness policy: fair locks grant the lock to the thread waiting longest, reducing starvation but lowering throughput.

Code Walkthrough

This class shows safe lock usage with try-finally and demonstrates tryLock with a timeout limit.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;
public class LockDemo {
    private final Lock lock = new ReentrantLock();
public void safeOperation() {
        lock.lock(); // Blocks until acquired
        try {
            // Modify shared state here
        } finally {
            lock.unlock(); // Always release in finally block!
        }
    }
public void tryOperationWithTimeout() {
        try {
            // Attempt to acquire lock for 1 second
            if (lock.tryLock(1, TimeUnit.SECONDS)) {
                try {
                    System.out.println("Lock acquired!");
                } finally {
                    lock.unlock();
                }
            } else {
                System.out.println("Could not acquire lock, performing backup task");
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }
}

Interview-Relevant Information