Interview contents

Explicit Locks in Java — ReentrantLock

The synchronized keyword provides a simple way to achieve thread safety, but it has limitations — lack of flexibility, fairness control, and advanced features.
Java’s Lock interface (in java.util.concurrent.locks) and its primary implementation ReentrantLock provide more powerful synchronization mechanisms.

1. Introduction to Lock Interface

Lock is an alternative to intrinsic locks (monitors used by synchronized).
Provides explicit methods to acquire and release locks (lock(), unlock()).
Offers advanced features like fairness, timed lock acquisition, and multiple condition variables.

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class SharedResource {
    private final Lock lock = new ReentrantLock();
    private int counter = 0;

    public void increment() {
        lock.lock();   // Acquire lock
        try {
            counter++;
        } finally {
            lock.unlock(); // Always release in finally
        }
    }

    public int getCounter() {
        return counter;
    }
}

2. ReentrantLock Features

2.1 Basic Lock/Unlock

lock() acquires the lock, blocking if unavailable.
unlock() releases it.
⚠️ Must always call unlock() in a finally block to avoid deadlocks.

2.2 tryLock()

Attempts to acquire lock without blocking indefinitely.
Returns true if lock acquired, false otherwise.

if (lock.tryLock()) {
    try {
        // Critical section
    } finally {
        lock.unlock();
    }
} else {
    // Could not acquire lock, do something else
}

2.3 Timeout Lock

if (lock.tryLock(1, TimeUnit.SECONDS)) {
    try {
        // work
    } finally {
        lock.unlock();
    }
}

2.4 Fair vs Non-Fair Locks

By default, ReentrantLock is non-fair (threads may barge in).
With fairness set to true: new ReentrantLock(true), threads acquire in FIFO order.
Fair locks reduce starvation but are slower.

2.5 Condition Variables

Condition objects (via lock.newCondition()) allow fine-grained thread communication.
Similar to wait()/notify(), but more flexible.

import java.util.concurrent.locks.Condition;

class BoundedBuffer {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final int[] items = new int[5];
    private int count, putPtr, takePtr;

    public void put(int x) throws InterruptedException {
        lock.lock();
        try {
            while (count == items.length) notFull.await();
            items[putPtr] = x;
            putPtr = (putPtr + 1) % items.length;
            count++;
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public int take() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) notEmpty.await();
            int x = items[takePtr];
            takePtr = (takePtr + 1) % items.length;
            count--;
            notFull.signal();
            return x;
        } finally {
            lock.unlock();
        }
    }
}

3. Example: Producer-Consumer with ReentrantLock

class ProducerConsumer {
    private final Lock lock = new ReentrantLock();
    private final Condition notFull = lock.newCondition();
    private final Condition notEmpty = lock.newCondition();
    private final int[] buffer = new int[5];
    private int count, putPtr, takePtr;

    public void produce(int value) throws InterruptedException {
        lock.lock();
        try {
            while (count == buffer.length) notFull.await();
            buffer[putPtr] = value;
            putPtr = (putPtr + 1) % buffer.length;
            count++;
            System.out.println("Produced: " + value);
            notEmpty.signal();
        } finally {
            lock.unlock();
        }
    }

    public int consume() throws InterruptedException {
        lock.lock();
        try {
            while (count == 0) notEmpty.await();
            int value = buffer[takePtr];
            takePtr = (takePtr + 1) % buffer.length;
            count--;
            System.out.println("Consumed: " + value);
            notFull.signal();
            return value;
        } finally {
            lock.unlock();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        Runnable producer = () -> {
            for (int i = 0; i < 10; i++) {
                try {
                    pc.produce(i);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        Runnable consumer = () -> {
            for (int i = 0; i < 10; i++) {
                try {
                    pc.consume();
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        };

        new Thread(producer).start();
        new Thread(consumer).start();
    }
}

4. Interview Focus: Synchronized vs ReentrantLock

Aspect	synchronized	ReentrantLock
Acquisition	Implicit (monitor)	Explicit (`lock()`)
Release	Automatic	Manual (`unlock()` required)
Fairness	Not possible	Fair or non-fair
Try/Timeout Lock	Not available	Available (`tryLock()`)
Condition Variables	Single (`wait/notify`)	Multiple (`Condition`)
Readability	Simple	Verbose but flexible

Conclusion

ReentrantLock provides greater control than synchronized, with features like fairness, tryLock, and conditions.
However, it requires manual discipline (must unlock).
For most cases, synchronized is enough. Use ReentrantLock when advanced features are needed.