Comprehensive comparison between ReentrantLock and synchronized for thread synchronization in Java.

1. Basic Usage Comparison

Synchronized Approach

public class SynchronizedExample { private int counter = 0; private final Object lock = new Object(); // Synchronized method public synchronized void increment() { counter++; } // Synchronized block public void incrementWithBlock() { synchronized (lock) { counter++; } } // Synchronized static method public static synchronized void staticMethod() { // Synchronized on class object } public int getCounter() { return counter; } }

ReentrantLock Approach

import java.util.concurrent.locks.ReentrantLock; public class ReentrantLockExample { private int counter = 0; private final ReentrantLock lock = new ReentrantLock(); public void increment() { lock.lock(); // Acquire the lock try { counter++; } finally { lock.unlock(); // Always release in finally block } } public int getCounter() { return counter; } }

2. Key Differences and Features

Feature Comparison Table

public class FeatureComparison { public static void main(String[] args) { System.out.println("=== ReentrantLock vs Synchronized ==="); System.out.println("Feature\t\t\tSynchronized\tReentrantLock"); System.out.println("--------\t\t-----------\t------------"); System.out.println("Reentrant\t\tYes\t\tYes"); System.out.println("Fair locking\t\tNo\t\tOptional"); System.out.println("Try lock\t\tNo\t\tYes"); System.out.println("Lock interruption\tNo\t\tYes"); System.out.println("Timeout support\t\tNo\t\tYes"); System.out.println("Condition support\tLimited\t\tYes"); System.out.println("Performance\t\tGood\t\tBetter in contention"); } }

3. Advanced ReentrantLock Features

Try Lock with Timeout

public class TryLockExample { private final ReentrantLock lock = new ReentrantLock(); private final List<String> data = new ArrayList<>(); public boolean addDataWithTimeout(String item, long timeout, TimeUnit unit) { try { // Try to acquire lock with timeout if (lock.tryLock(timeout, unit)) { try { // Critical section Thread.sleep(100); // Simulate work data.add(item); return true; } finally { lock.unlock(); } } else { System.out.println("Could not acquire lock within timeout"); return false; } } catch (InterruptedException e) { Thread.currentThread().interrupt(); return false; } } public boolean tryAddData(String item) { // Non-blocking try if (lock.tryLock()) { try { data.add(item); return true; } finally { lock.unlock(); } } else { System.out.println("Lock is held by another thread"); return false; } } }

Interruptible Locking

public class InterruptibleLockExample { private final ReentrantLock lock = new ReentrantLock(); public void performTask() throws InterruptedException { System.out.println(Thread.currentThread().getName() + " attempting to acquire lock"); lock.lockInterruptibly(); // This can be interrupted try { System.out.println(Thread.currentThread().getName() + " acquired lock"); // Simulate long-running task for (int i = 0; i < 5; i++) { System.out.println(Thread.currentThread().getName() + " working... " + i); Thread.sleep(1000); // Check if interrupted during work if (Thread.currentThread().isInterrupted()) { System.out.println(Thread.currentThread().getName() + " was interrupted during work"); break; } } } finally { if (lock.isHeldByCurrentThread()) { lock.unlock(); System.out.println(Thread.currentThread().getName() + " released lock"); } } } public static void demonstrateInterruption() throws Exception { InterruptibleLockExample example = new InterruptibleLockExample(); Thread worker1 = new Thread(() -> { try { example.performTask(); } catch (InterruptedException e) { System.out.println("Worker 1 was interrupted while waiting for lock"); } }, "Worker-1"); Thread worker2 = new Thread(() -> { try { example.performTask(); } catch (InterruptedException e) { System.out.println("Worker 2 was interrupted while waiting for lock"); } }, "Worker-2"); worker1.start(); Thread.sleep(100); // Ensure worker1 gets lock first worker2.start(); Thread.sleep(100); // Let worker2 start waiting for lock // Interrupt worker2 while it's waiting for the lock worker2.interrupt(); worker1.join(); worker2.join(); } }

Fair Locking

public class FairLockExample { private final ReentrantLock fairLock = new ReentrantLock(true); // Fair lock private final ReentrantLock unfairLock = new ReentrantLock(); // Unfair lock (default) public void demonstrateFairness() throws InterruptedException { System.out.println("=== Fair Lock Demonstration ==="); // Test fair lock testLock("Fair Lock", fairLock); Thread.sleep(2000); System.out.println("\n=== Unfair Lock Demonstration ==="); // Test unfair lock testLock("Unfair Lock", unfairLock); } private void testLock(String lockType, ReentrantLock lock) throws InterruptedException { int threadCount = 5; CountDownLatch startLatch = new CountDownLatch(1); CountDownLatch endLatch = new CountDownLatch(threadCount); for (int i = 0; i < threadCount; i++) { final int threadId = i; new Thread(() -> { try { startLatch.await(); // Wait for start signal lock.lock(); try { System.out.println(lockType + " acquired by Thread-" + threadId + " at " + System.currentTimeMillis()); Thread.sleep(100); // Hold lock briefly } finally { lock.unlock(); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } finally { endLatch.countDown(); } }, "Thread-" + threadId).start(); } // Start all threads at once startLatch.countDown(); endLatch.await(); // Wait for all threads to complete } }

4. Condition Variables with ReentrantLock

Producer-Consumer with Conditions

public class ProducerConsumerWithConditions { private final ReentrantLock lock = new ReentrantLock(); private final Condition notEmpty = lock.newCondition(); // Condition for consumers private final Condition notFull = lock.newCondition(); // Condition for producers private final Queue<Integer> queue = new LinkedList<>(); private final int capacity; public ProducerConsumerWithConditions(int capacity) { this.capacity = capacity; } public void produce(int value) throws InterruptedException { lock.lock(); try { // Wait until queue is not full while (queue.size() == capacity) { System.out.println("Queue full, producer waiting..."); notFull.await(); // Releases lock and waits } queue.offer(value); System.out.println("Produced: " + value + ", queue size: " + queue.size()); // Signal consumers that queue is not empty notEmpty.signalAll(); } finally { lock.unlock(); } } public int consume() throws InterruptedException { lock.lock(); try { // Wait until queue is not empty while (queue.isEmpty()) { System.out.println("Queue empty, consumer waiting..."); notEmpty.await(); // Releases lock and waits } int value = queue.poll(); System.out.println("Consumed: " + value + ", queue size: " + queue.size()); // Signal producers that queue is not full notFull.signalAll(); return value; } finally { lock.unlock(); } } // Demonstration public static void main(String[] args) throws Exception { ProducerConsumerWithConditions pc = new ProducerConsumerWithConditions(3); // Producer thread Thread producer = new Thread(() -> { try { for (int i = 1; i <= 10; i++) { pc.produce(i); Thread.sleep(200); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); // Consumer thread Thread consumer = new Thread(() -> { try { for (int i = 1; i <= 10; i++) { pc.consume(); Thread.sleep(300); } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }); producer.start(); consumer.start(); producer.join(); consumer.join(); } }

Multiple Conditions Example

public class MultipleConditionsExample { private final ReentrantLock lock = new ReentrantLock(); private final Condition dataAvailable = lock.newCondition(); private final Condition processingDone = lock.newCondition(); private boolean dataReady = false; private boolean processingComplete = false; private String data; public void produceData(String data) throws InterruptedException { lock.lock(); try { // Wait if previous data hasn't been processed while (dataReady) { processingDone.await(); } this.data = data; dataReady = true; System.out.println("Produced data: " + data); // Signal that data is available dataAvailable.signalAll(); } finally { lock.unlock(); } } public String consumeData() throws InterruptedException { lock.lock(); try { // Wait for data to be available while (!dataReady) { dataAvailable.await(); } String consumedData = this.data; System.out.println("Consumed data: " + consumedData); return consumedData; } finally { lock.unlock(); } } public void processData() throws InterruptedException { lock.lock(); try { String data = consumeData(); // Simulate processing Thread.sleep(1000); System.out.println("Processed data: " + data.toUpperCase()); // Reset state dataReady = false; this.data = null; processingComplete = true; // Signal that processing is done processingDone.signalAll(); } finally { lock.unlock(); } } }

5. Performance Comparison

Benchmark Example

public class LockPerformanceBenchmark { private static final int ITERATIONS = 10_000; private static final int THREAD_COUNT = 10; // Synchronized implementation static class SynchronizedCounter { private int count = 0; public synchronized void increment() { count++; } public synchronized int getCount() { return count; } } // ReentrantLock implementation static class ReentrantLockCounter { private int count = 0; private final ReentrantLock lock = new ReentrantLock(); public void increment() { lock.lock(); try { count++; } finally { lock.unlock(); } } public int getCount() { lock.lock(); try { return count; } finally { lock.unlock(); } } } public static void benchmark() throws InterruptedException { System.out.println("=== Performance Benchmark ==="); System.out.println("Iterations: " + ITERATIONS); System.out.println("Threads: " + THREAD_COUNT); // Test synchronized long syncTime = testSynchronized(); System.out.printf("Synchronized time: %d ms%n", syncTime); // Test ReentrantLock long lockTime = testReentrantLock(); System.out.printf("ReentrantLock time: %d ms%n", lockTime); System.out.printf("ReentrantLock is %.2fx %s%n", (double) syncTime / lockTime, lockTime < syncTime ? "faster" : "slower"); } private static long testSynchronized() throws InterruptedException { SynchronizedCounter counter = new SynchronizedCounter(); CountDownLatch latch = new CountDownLatch(THREAD_COUNT); long startTime = System.currentTimeMillis(); for (int i = 0; i < THREAD_COUNT; i++) { new Thread(() -> { for (int j = 0; j < ITERATIONS; j++) { counter.increment(); } latch.countDown(); }).start(); } latch.await(); long endTime = System.currentTimeMillis(); System.out.println("Synchronized final count: " + counter.getCount()); return endTime - startTime; } private static long testReentrantLock() throws InterruptedException { ReentrantLockCounter counter = new ReentrantLockCounter(); CountDownLatch latch = new CountDownLatch(THREAD_COUNT); long startTime = System.currentTimeMillis(); for (int i = 0; i < THREAD_COUNT; i++) { new Thread(() -> { for (int j = 0; j < ITERATIONS; j++) { counter.increment(); } latch.countDown(); }).start(); } latch.await(); long endTime = System.currentTimeMillis(); System.out.println("ReentrantLock final count: " + counter.getCount()); return endTime - startTime; } }

6. Real-World Use Cases

Resource Pool with ReentrantLock

public class ResourcePool<T> { private final ReentrantLock lock = new ReentrantLock(true); // Fair lock private final Condition resourceAvailable = lock.newCondition(); private final Queue<T> availableResources; private final Set<T> allocatedResources; private final int maxSize; public ResourcePool(int maxSize) { this.maxSize = maxSize; this.availableResources = new LinkedList<>(); this.allocatedResources = new HashSet<>(); } public T acquire() throws InterruptedException { lock.lock(); try { // Wait until resource is available or pool can be expanded while (availableResources.isEmpty() && allocatedResources.size() == maxSize) { resourceAvailable.await(); } T resource; if (availableResources.isEmpty()) { // Create new resource (simulated) resource = createResource(); } else { resource = availableResources.poll(); } allocatedResources.add(resource); return resource; } finally { lock.unlock(); } } public T acquire(long timeout, TimeUnit unit) throws InterruptedException { lock.lock(); try { long nanos = unit.toNanos(timeout); while (availableResources.isEmpty() && allocatedResources.size() == maxSize) { if (nanos <= 0) { return null; // Timeout } nanos = resourceAvailable.awaitNanos(nanos); } T resource; if (availableResources.isEmpty()) { resource = createResource(); } else { resource = availableResources.poll(); } allocatedResources.add(resource); return resource; } finally { lock.unlock(); } } public void release(T resource) { lock.lock(); try { if (allocatedResources.remove(resource)) { availableResources.offer(resource); resourceAvailable.signalAll(); // Notify waiting threads } } finally { lock.unlock(); } } @SuppressWarnings("unchecked") private T createResource() { // Simulate resource creation return (T) new Object(); } public int getAvailableCount() { lock.lock(); try { return availableResources.size(); } finally { lock.unlock(); } } public int getAllocatedCount() { lock.lock(); try { return allocatedResources.size(); } finally { lock.unlock(); } } }

Cache with Read-Write Locking

public class ReadWriteLockCache<K, V> { private final ReentrantLock mainLock = new ReentrantLock(); private final Map<K, V> cache = new HashMap<>(); private int readCount = 0; private final Condition canRead = mainLock.newCondition(); private final Condition canWrite = mainLock.newCondition(); private boolean isWriting = false; // Simpler alternative: use ReadWriteLock private final java.util.concurrent.locks.ReadWriteLock rwLock = new java.util.concurrent.locks.ReentrantReadWriteLock(); private final Map<K, V> simpleCache = new HashMap<>(); // Using manual read-write lock implementation public V get(K key) throws InterruptedException { mainLock.lock(); try { // Wait if someone is writing while (isWriting) { canRead.await(); } readCount++; } finally { mainLock.unlock(); } try { return cache.get(key); } finally { mainLock.lock(); try { readCount--; if (readCount == 0) { canWrite.signal(); // Signal writers if no readers } } finally { mainLock.unlock(); } } } public void put(K key, V value) throws InterruptedException { mainLock.lock(); try { // Wait if someone is writing or reading while (isWriting || readCount > 0) { canWrite.await(); } isWriting = true; } finally { mainLock.unlock(); } try { // Perform write operation cache.put(key, value); Thread.sleep(10); // Simulate write time } finally { mainLock.lock(); try { isWriting = false; canRead.signalAll(); // Signal all readers canWrite.signal(); // Signal one writer } finally { mainLock.unlock(); } } } // Simpler approach using built-in ReadWriteLock public V getSimple(K key) { rwLock.readLock().lock(); try { return simpleCache.get(key); } finally { rwLock.readLock().unlock(); } } public void putSimple(K key, V value) { rwLock.writeLock().lock(); try { simpleCache.put(key, value); } finally { rwLock.writeLock().unlock(); } } }

7. Best Practices and Pitfalls

Common Mistakes and Solutions

public class LockBestPractices { // ✅ GOOD: Always unlock in finally block public void goodPractice(ReentrantLock lock) { lock.lock(); try { // Critical section performOperation(); } finally { lock.unlock(); } } // ❌ BAD: Might not unlock if exception occurs public void badPractice(ReentrantLock lock) { lock.lock(); performOperation(); lock.unlock(); // If exception occurs before this, lock won't be released } // ✅ GOOD: Check if current thread holds lock before unlocking public void safeUnlock(ReentrantLock lock) { if (lock.isHeldByCurrentThread()) { lock.unlock(); } } // ✅ GOOD: Using tryLock with resource management public void withTryLock(ReentrantLock lock) { if (lock.tryLock()) { try { // Critical section performOperation(); } finally { lock.unlock(); } } else { // Alternative approach when lock is not available performAlternativeOperation(); } } // ❌ BAD: Nested locking can cause deadlocks public void potentialDeadlock(ReentrantLock lock1, ReentrantLock lock2) { lock1.lock(); try { // Some operation lock2.lock(); // Dangerous if another thread does the reverse try { // Nested critical section } finally { lock2.unlock(); } } finally { lock1.unlock(); } } // ✅ GOOD: Consistent lock ordering to prevent deadlocks public void safeNestedLocking(ReentrantLock lock1, ReentrantLock lock2) { // Always acquire locks in the same order ReentrantLock firstLock, secondLock; if (lock1.hashCode() < lock2.hashCode()) { firstLock = lock1; secondLock = lock2; } else { firstLock = lock2; secondLock = lock1; } firstLock.lock(); try { secondLock.lock(); try { // Nested critical section } finally { secondLock.unlock(); } } finally { firstLock.unlock(); } } private void performOperation() { // Some operation } private void performAlternativeOperation() { // Alternative operation } }

When to Use Which

public class LockSelectionGuide { /* * Use Synchronized when: * - Simple synchronization needs * - Basic critical sections * - When you want JVM to handle lock management * - When you don't need advanced features */ public synchronized void useSynchronized() { // Simple critical section } /* * Use ReentrantLock when: * - You need tryLock() functionality * - You need fair locking * - You need lock interruption * - You need multiple condition variables * - You need to check lock status */ public void useReentrantLock() { ReentrantLock lock = new ReentrantLock(); if (lock.tryLock()) { try { // Critical section with advanced features } finally { lock.unlock(); } } } /* * Use ReadWriteLock when: * - Multiple readers, infrequent writers * - Read-heavy workloads * - You want to allow concurrent reads */ public void useReadWriteLock() { java.util.concurrent.locks.ReadWriteLock rwLock = new java.util.concurrent.locks.ReentrantReadWriteLock(); // For reads rwLock.readLock().lock(); try { // Multiple threads can read concurrently } finally { rwLock.readLock().unlock(); } // For writes rwLock.writeLock().lock(); try { // Only one thread can write } finally { rwLock.writeLock().unlock(); } } }

Summary

Choose synchronized for simple cases and ReentrantLock when you need advanced features like try-lock, fair ordering, or multiple condition variables.