google-site-verification: google61fe8ba583a51912.html
MACRO NEPAL
Deadlock Prevention in Java – Complete Guide
awiskar acharya
October 30, 2025
11:53 am

Overview

Deadlock occurs when two or more threads are blocked forever, each waiting for a resource held by the other. Prevention strategies include resource ordering, timeouts, and careful lock acquisition.

1. Understanding Deadlock

Deadlock Conditions & Example

public class DeadlockExample { static class Resource { private final String name; public Resource(String name) { this.name = name; } public String getName() { return name; } public synchronized void use() { System.out.println(Thread.currentThread().getName() + " using " + name); try { Thread.sleep(100); // Simulate work } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } public synchronized void useWith(Resource other) { System.out.println(Thread.currentThread().getName() + " attempting to use " + name + " with " + other.getName()); // First lock acquired on 'this' use(); // Attempt to acquire second lock - POTENTIAL DEADLOCK other.use(); } } public static void main(String[] args) throws InterruptedException { System.out.println("=== Deadlock Demonstration ==="); Resource resourceA = new Resource("Resource-A"); Resource resourceB = new Resource("Resource-B"); // Thread 1: Lock A then B Thread t1 = new Thread(() -> { resourceA.useWith(resourceB); }, "Thread-1-A-then-B"); // Thread 2: Lock B then A (OPPOSITE ORDER - DEADLOCK!) Thread t2 = new Thread(() -> { resourceB.useWith(resourceA); }, "Thread-2-B-then-A"); t1.start(); t2.start(); // Wait for threads with timeout t1.join(2000); t2.join(2000); if (t1.isAlive() || t2.isAlive()) { System.out.println("\n*** DEADLOCK DETECTED! ***"); System.out.println("Thread-1 state: " + t1.getState()); System.out.println("Thread-2 state: " + t2.getState()); // Interrupt threads to break deadlock t1.interrupt(); t2.interrupt(); } else { System.out.println("No deadlock occurred"); } t1.join(); t2.join(); } }

Deadlock Detection Utility

public class DeadlockDetector { public static void monitorDeadlocks() { Thread detectorThread = new Thread(() -> { while (true) { checkForDeadlocks(); try { Thread.sleep(5000); // Check every 5 seconds } catch (InterruptedException e) { break; } } }); detectorThread.setDaemon(true); detectorThread.start(); } private static void checkForDeadlocks() { ThreadMXBean threadBean = ManagementFactory.getThreadMXBean(); long[] threadIds = threadBean.findDeadlockedThreads(); if (threadIds != null) { System.out.println("\n*** DEADLOCK DETECTED ***"); ThreadInfo[] threadInfos = threadBean.getThreadInfo(threadIds); for (ThreadInfo threadInfo : threadInfos) { System.out.println("Deadlocked Thread: " + threadInfo.getThreadName()); System.out.println(" State: " + threadInfo.getThreadState()); LockInfo lockInfo = threadInfo.getLockInfo(); if (lockInfo != null) { System.out.println(" Waiting on: " + lockInfo); } // Print stack trace System.out.println(" Stack Trace:"); for (StackTraceElement element : threadInfo.getStackTrace()) { System.out.println(" " + element); } System.out.println(); } } } public static void main(String[] args) throws InterruptedException { // Start deadlock monitoring monitorDeadlocks(); // Create deadlock scenario Object lock1 = new Object(); Object lock2 = new Object(); Thread t1 = new Thread(() -> { synchronized (lock1) { System.out.println("Thread-1 acquired lock1"); try { Thread.sleep(100); } catch (InterruptedException e) {} synchronized (lock2) { System.out.println("Thread-1 acquired lock2"); } } }, "Deadlock-Thread-1"); Thread t2 = new Thread(() -> { synchronized (lock2) { System.out.println("Thread-2 acquired lock2"); try { Thread.sleep(100); } catch (InterruptedException e) {} synchronized (lock1) { System.out.println("Thread-2 acquired lock1"); } } }, "Deadlock-Thread-2"); t1.start(); t2.start(); // Let deadlock occur and be detected Thread.sleep(3000); } }

2. Resource Ordering Prevention

Fixed Order Locking

public class ResourceOrdering { static class OrderedResource { private final String name; private final int orderId; public OrderedResource(String name, int orderId) { this.name = name; this.orderId = orderId; } public String getName() { return name; } public int getOrderId() { return orderId; } public synchronized void use() { System.out.println(Thread.currentThread().getName() + " using " + name); try { Thread.sleep(50); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } } } static class ResourceManager { // Always acquire locks in order of orderId public static void useResources(OrderedResource res1, OrderedResource res2) { // Determine lock order based on orderId OrderedResource first, second; if (res1.getOrderId() < res2.getOrderId()) { first = res1; second = res2; } else { first = res2; second = res1; } // Always lock in consistent order synchronized (first) { System.out.println(Thread.currentThread().getName() + " locked " + first.getName()); synchronized (second) { System.out.println(Thread.currentThread().getName() + " locked " + second.getName()); // Use both resources res1.use(); res2.use(); System.out.println(Thread.currentThread().getName() + " completed work with both resources"); } } } // Alternative: Use System.identityHashCode for ordering when no natural order exists public static void useResourcesUniversal(Object res1, Object res2) { Object first, second; if (System.identityHashCode(res1) < System.identityHashCode(res2)) { first = res1; second = res2; } else { first = res2; second = res1; } synchronized (first) { synchronized (second) { // Critical section System.out.println(Thread.currentThread().getName() + " safely acquired both locks"); } } } } public static void main(String[] args) throws InterruptedException { System.out.println("=== Resource Ordering Prevention ==="); // Create resources with explicit ordering OrderedResource resourceA = new OrderedResource("Database", 1); OrderedResource resourceB = new OrderedResource("FileSystem", 2); OrderedResource resourceC = new OrderedResource("Network", 3); // Multiple threads using resources in different combinations Thread[] threads = new Thread[6]; // Thread 1: A then B threads[0] = new Thread(() -> { ResourceManager.useResources(resourceA, resourceB); }, "Thread-A-B"); // Thread 2: B then A (will be reordered to A then B) threads[1] = new Thread(() -> { ResourceManager.useResources(resourceB, resourceA); }, "Thread-B-A"); // Thread 3: B then C threads[2] = new Thread(() -> { ResourceManager.useResources(resourceB, resourceC); }, "Thread-B-C"); // Thread 4: C then A threads[3] = new Thread(() -> { ResourceManager.useResources(resourceC, resourceA); }, "Thread-C-A"); // Thread 5: All three resources threads[4] = new Thread(() -> { // For multiple resources, sort them first OrderedResource[] resources = {resourceC, resourceA, resourceB}; java.util.Arrays.sort(resources, (r1, r2) -> Integer.compare(r1.getOrderId(), r2.getOrderId())); synchronized (resources[0]) { synchronized (resources[1]) { synchronized (resources[2]) { System.out.println(Thread.currentThread().getName() + " acquired all three resources safely"); } } } }, "Thread-All-Three"); // Thread 6: Universal ordering threads[5] = new Thread(() -> { ResourceManager.useResourcesUniversal(new Object(), new Object()); }, "Thread-Universal"); // Start all threads for (Thread thread : threads) { thread.start(); } // Wait for completion for (Thread thread : threads) { thread.join(); } System.out.println("All threads completed without deadlock!"); } }

Bank Account Transfer with Ordered Locking

public class BankTransferOrdering { static class BankAccount { private final String accountNumber; private double balance; public BankAccount(String accountNumber, double initialBalance) { this.accountNumber = accountNumber; this.balance = initialBalance; } public String getAccountNumber() { return accountNumber; } public double getBalance() { return balance; } public void debit(double amount) { if (amount > 0 && balance >= amount) { balance -= amount; } } public void credit(double amount) { if (amount > 0) { balance += amount; } } } static class Bank { // Deadlock-prone transfer method public static void transferWithDeadlock(BankAccount from, BankAccount to, double amount) { synchronized (from) { System.out.println(Thread.currentThread().getName() + " locked " + from.getAccountNumber()); try { Thread.sleep(50); } catch (InterruptedException e) {} synchronized (to) { System.out.println(Thread.currentThread().getName() + " locked " + to.getAccountNumber()); if (from.getBalance() >= amount) { from.debit(amount); to.credit(amount); System.out.println("Transferred " + amount + " from " + from.getAccountNumber() + " to " + to.getAccountNumber()); } } } } // Deadlock-free transfer with ordering public static void transferSafe(BankAccount from, BankAccount to, double amount) { // Determine lock order based on account number BankAccount firstLock, secondLock; int compare = from.getAccountNumber().compareTo(to.getAccountNumber()); if (compare < 0) { firstLock = from; secondLock = to; } else if (compare > 0) { firstLock = to; secondLock = from; } else { // Same account - no transfer needed return; } synchronized (firstLock) { System.out.println(Thread.currentThread().getName() + " locked " + firstLock.getAccountNumber()); synchronized (secondLock) { System.out.println(Thread.currentThread().getName() + " locked " + secondLock.getAccountNumber()); if (from.getBalance() >= amount) { from.debit(amount); to.credit(amount); System.out.println("Transferred " + amount + " from " + from.getAccountNumber() + " to " + to.getAccountNumber()); } else { System.out.println("Insufficient funds in " + from.getAccountNumber()); } } } } } public static void main(String[] args) throws InterruptedException { System.out.println("=== Bank Transfer Deadlock Prevention ==="); BankAccount account1 = new BankAccount("ACC-001", 1000); BankAccount account2 = new BankAccount("ACC-002", 1000); BankAccount account3 = new BankAccount("ACC-003", 1000); // Test concurrent transfers Thread t1 = new Thread(() -> { for (int i = 0; i < 5; i++) { Bank.transferSafe(account1, account2, 100); try { Thread.sleep(10); } catch (InterruptedException e) {} } }, "Transfer-1-to-2"); Thread t2 = new Thread(() -> { for (int i = 0; i < 5; i++) { Bank.transferSafe(account2, account1, 50); // Reverse direction try { Thread.sleep(15); } catch (InterruptedException e) {} } }, "Transfer-2-to-1"); Thread t3 = new Thread(() -> { for (int i = 0; i < 5; i++) { Bank.transferSafe(account1, account3, 75); try { Thread.sleep(20); } catch (InterruptedException e) {} } }, "Transfer-1-to-3"); Thread t4 = new Thread(() -> { for (int i = 0; i < 5; i++) { Bank.transferSafe(account3, account2, 25); try { Thread.sleep(25); } catch (InterruptedException e) {} } }, "Transfer-3-to-2"); t1.start(); t2.start(); t3.start(); t4.start(); t1.join(); t2.join(); t3.join(); t4.join(); System.out.println("\nFinal Balances:"); System.out.println("Account 1: " + account1.getBalance()); System.out.println("Account 2: " + account2.getBalance()); System.out.println("Account 3: " + account3.getBalance()); System.out.println("Total: " + (account1.getBalance() + account2.getBalance() + account3.getBalance())); } }

3. Timeout-Based Prevention

Try-Lock with Timeout

import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; public class TimeoutPrevention { static class TimeoutResource { private final String name; private final Lock lock = new ReentrantLock(); public TimeoutResource(String name) { this.name = name; } public String getName() { return name; } public boolean tryUse(long timeout, TimeUnit unit) throws InterruptedException { if (lock.tryLock(timeout, unit)) { try { System.out.println(Thread.currentThread().getName() + " acquired " + name); Thread.sleep(100); // Simulate work return true; } finally { lock.unlock(); System.out.println(Thread.currentThread().getName() + " released " + name); } } return false; } public void use() throws InterruptedException { lock.lock(); try { System.out.println(Thread.currentThread().getName() + " using " + name); Thread.sleep(100); } finally { lock.unlock(); } } } static class TimeoutResourceManager { // Attempt to acquire both resources with timeout public static boolean useBothWithTimeout(TimeoutResource res1, TimeoutResource res2, long timeout, TimeUnit unit) throws InterruptedException { long startTime = System.nanoTime(); long timeoutNanos = unit.toNanos(timeout); // Try to acquire first lock if (!res1.tryUse(timeout, unit)) { System.out.println(Thread.currentThread().getName() + " failed to acquire " + res1.getName()); return false; } try { // Calculate remaining time for second lock long elapsed = System.nanoTime() - startTime; long remainingTime = timeoutNanos - elapsed; if (remainingTime <= 0) { System.out.println(Thread.currentThread().getName() + " timeout acquiring " + res2.getName()); return false; } // Try to acquire second lock with remaining time if (res2.tryUse(remainingTime, TimeUnit.NANOSECONDS)) { System.out.println(Thread.currentThread().getName() + " successfully used both resources"); return true; } else { System.out.println(Thread.currentThread().getName() + " failed to acquire " + res2.getName()); return false; } } finally { // First lock will be released automatically by tryUse } } // Alternative: Acquire in ordered fashion with timeout public static boolean useBothOrderedWithTimeout(TimeoutResource res1, TimeoutResource res2, long timeout, TimeUnit unit) throws InterruptedException { // Determine order TimeoutResource first, second; if (res1.getName().compareTo(res2.getName()) < 0) { first = res1; second = res2; } else { first = res2; second = res1; } return useBothWithTimeout(first, second, timeout, unit); } } public static void main(String[] args) throws InterruptedException { System.out.println("=== Timeout-Based Deadlock Prevention ==="); TimeoutResource resourceA = new TimeoutResource("Resource-A"); TimeoutResource resourceB = new TimeoutResource("Resource-B"); // Thread with sufficient timeout Thread t1 = new Thread(() -> { try { boolean success = TimeoutResourceManager.useBothWithTimeout( resourceA, resourceB, 2, TimeUnit.SECONDS); System.out.println("Thread-1 result: " + (success ? "SUCCESS" : "FAILED")); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "Thread-1-Long-Timeout"); // Thread with very short timeout (will likely fail) Thread t2 = new Thread(() -> { try { boolean success = TimeoutResourceManager.useBothOrderedWithTimeout( resourceB, resourceA, 50, TimeUnit.MILLISECONDS); System.out.println("Thread-2 result: " + (success ? "SUCCESS" : "FAILED")); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "Thread-2-Short-Timeout"); // Thread that causes contention Thread t3 = new Thread(() -> { try { // Hold resource A for a while if (resourceA.tryUse(1, TimeUnit.SECONDS)) { System.out.println("Thread-3 holding Resource-A"); Thread.sleep(500); // Hold the lock } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "Thread-3-Contention"); t3.start(); Thread.sleep(100); // Let t3 acquire the lock first t1.start(); t2.start(); t1.join(); t2.join(); t3.join(); System.out.println("Timeout prevention demo completed"); } }

4. Lock Hierarchy & Resource Management

Hierarchical Locking System

public class HierarchicalLocking { static class LockLevel { public static final int DATABASE = 1; public static final int FILE_SYSTEM = 2; public static final int NETWORK = 3; public static final int MEMORY = 4; } static class HierarchicalResource { private final String name; private final int level; private final Object lock = new Object(); private boolean locked = false; public HierarchicalResource(String name, int level) { this.name = name; this.level = level; } public String getName() { return name; } public int getLevel() { return level; } public boolean acquire() { synchronized (lock) { if (!locked) { locked = true; System.out.println(Thread.currentThread().getName() + " acquired " + name + " (level " + level + ")"); return true; } return false; } } public void release() { synchronized (lock) { locked = false; System.out.println(Thread.currentThread().getName() + " released " + name); lock.notifyAll(); } } public boolean waitAndAcquire(long timeout) throws InterruptedException { synchronized (lock) { long endTime = System.currentTimeMillis() + timeout; long remaining = timeout; while (locked && remaining > 0) { lock.wait(remaining); remaining = endTime - System.currentTimeMillis(); } if (!locked) { locked = true; System.out.println(Thread.currentThread().getName() + " acquired " + name + " after wait"); return true; } return false; } } } static class HierarchicalResourceManager { // Acquire resources in level order (lowest to highest) public static boolean acquireResources(HierarchicalResource[] resources, long timeout) throws InterruptedException { // Sort resources by level java.util.Arrays.sort(resources, (r1, r2) -> Integer.compare(r1.getLevel(), r2.getLevel())); boolean allAcquired = false; int acquiredCount = 0; try { long startTime = System.currentTimeMillis(); long remaining = timeout; // Acquire in order for (HierarchicalResource resource : resources) { if (remaining <= 0) { break; } if (resource.waitAndAcquire(remaining)) { acquiredCount++; } else { break; } // Update remaining time long elapsed = System.currentTimeMillis() - startTime; remaining = timeout - elapsed; } allAcquired = (acquiredCount == resources.length); if (allAcquired) { System.out.println(Thread.currentThread().getName() + " successfully acquired all resources"); return true; } else { System.out.println(Thread.currentThread().getName() + " failed to acquire all resources"); return false; } } finally { // Release all acquired resources if we didn't get all if (!allAcquired) { for (int i = 0; i < acquiredCount; i++) { resources[i].release(); } } } } public static void releaseResources(HierarchicalResource[] resources) { // Release in reverse order (not strictly necessary but good practice) for (int i = resources.length - 1; i >= 0; i--) { resources[i].release(); } } } public static void main(String[] args) throws InterruptedException { System.out.println("=== Hierarchical Locking ==="); // Create resources with different levels HierarchicalResource database = new HierarchicalResource("Database", LockLevel.DATABASE); HierarchicalResource filesystem = new HierarchicalResource("FileSystem", LockLevel.FILE_SYSTEM); HierarchicalResource network = new HierarchicalResource("Network", LockLevel.NETWORK); HierarchicalResource memory = new HierarchicalResource("Memory", LockLevel.MEMORY); HierarchicalResource[] allResources = {database, filesystem, network, memory}; // Thread 1: Acquire all resources in correct order Thread t1 = new Thread(() -> { try { if (HierarchicalResourceManager.acquireResources(allResources, 3000)) { try { System.out.println("Thread-1 working with all resources..."); Thread.sleep(1000); } finally { HierarchicalResourceManager.releaseResources(allResources); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "Thread-1-All-Resources"); // Thread 2: Try to acquire subset (should work due to hierarchy) Thread t2 = new Thread(() -> { try { HierarchicalResource[] subset = {database, filesystem}; if (HierarchicalResourceManager.acquireResources(subset, 2000)) { try { System.out.println("Thread-2 working with database and filesystem..."); Thread.sleep(500); } finally { HierarchicalResourceManager.releaseResources(subset); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "Thread-2-Subset"); // Thread 3: Try to acquire in different order (will be reordered by manager) Thread t3 = new Thread(() -> { try { HierarchicalResource[] reverseOrder = {memory, network, database}; if (HierarchicalResourceManager.acquireResources(reverseOrder, 2000)) { try { System.out.println("Thread-3 working with reordered resources..."); Thread.sleep(300); } finally { HierarchicalResourceManager.releaseResources(reverseOrder); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "Thread-3-Reverse-Order"); t1.start(); Thread.sleep(100); // Let t1 start first t2.start(); t3.start(); t1.join(); t2.join(); t3.join(); System.out.println("Hierarchical locking demo completed"); } }

5. Deadlock Prevention with Resource Pool

Resource Pool with Timeout

import java.util.*; import java.util.concurrent.*; public class ResourcePoolPrevention { static class PooledResource { private final String name; private volatile boolean inUse = false; private final Object lock = new Object(); public PooledResource(String name) { this.name = name; } public String getName() { return name; } public boolean acquire(long timeout, TimeUnit unit) throws InterruptedException { synchronized (lock) { long endTime = System.currentTimeMillis() + unit.toMillis(timeout); long remaining = unit.toMillis(timeout); while (inUse && remaining > 0) { lock.wait(remaining); remaining = endTime - System.currentTimeMillis(); } if (!inUse) { inUse = true; System.out.println(Thread.currentThread().getName() + " acquired " + name); return true; } return false; } } public void release() { synchronized (lock) { inUse = false; System.out.println(Thread.currentThread().getName() + " released " + name); lock.notifyAll(); } } public void use() throws InterruptedException { System.out.println(Thread.currentThread().getName() + " using " + name); Thread.sleep(100 + new Random().nextInt(100)); // Simulate work } } static class ResourcePool { private final Map<String, PooledResource> resources; public ResourcePool(Collection<PooledResource> resources) { this.resources = new HashMap<>(); for (PooledResource resource : resources) { this.resources.put(resource.getName(), resource); } } // Try to acquire multiple resources with deadlock prevention public List<PooledResource> acquireResources(Set<String> resourceNames, long timeout, TimeUnit unit) throws InterruptedException { // Convert to list and sort to ensure consistent order List<String> orderedNames = new ArrayList<>(resourceNames); Collections.sort(orderedNames); List<PooledResource> acquired = new ArrayList<>(); boolean success = false; try { long startTime = System.currentTimeMillis(); long remaining = unit.toMillis(timeout); // Acquire in consistent order for (String name : orderedNames) { if (remaining <= 0) { break; } PooledResource resource = resources.get(name); if (resource != null && resource.acquire(remaining, TimeUnit.MILLISECONDS)) { acquired.add(resource); } else { break; } // Update remaining time long elapsed = System.currentTimeMillis() - startTime; remaining = unit.toMillis(timeout) - elapsed; } success = (acquired.size() == resourceNames.size()); if (success) { System.out.println(Thread.currentThread().getName() + " successfully acquired all requested resources"); return acquired; } else { System.out.println(Thread.currentThread().getName() + " failed to acquire all resources"); return Collections.emptyList(); } } finally { // Release all if we didn't succeed if (!success) { releaseResources(acquired); } } } public void releaseResources(List<PooledResource> resources) { // Release in reverse order (good practice) for (int i = resources.size() - 1; i >= 0; i--) { resources.get(i).release(); } } // Single resource acquisition with fallback public PooledResource acquireResource(String name, long timeout, TimeUnit unit) throws InterruptedException { PooledResource resource = resources.get(name); if (resource != null && resource.acquire(timeout, unit)) { return resource; } return null; } } public static void main(String[] args) throws InterruptedException { System.out.println("=== Resource Pool Deadlock Prevention ==="); // Create resource pool List<PooledResource> resourceList = Arrays.asList( new PooledResource("Printer"), new PooledResource("Scanner"), new PooledResource("Database"), new PooledResource("Network") ); ResourcePool pool = new ResourcePool(resourceList); // Multiple threads requesting different resource combinations Thread t1 = new Thread(() -> { try { Set<String> requested = new HashSet<>(Arrays.asList("Printer", "Scanner")); List<PooledResource> acquired = pool.acquireResources(requested, 2000, TimeUnit.MILLISECONDS); if (!acquired.isEmpty()) { try { System.out.println("Thread-1 working with acquired resources..."); for (PooledResource resource : acquired) { resource.use(); } } finally { pool.releaseResources(acquired); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "Thread-1-Print-Scan"); Thread t2 = new Thread(() -> { try { Set<String> requested = new HashSet<>(Arrays.asList("Scanner", "Database")); List<PooledResource> acquired = pool.acquireResources(requested, 2000, TimeUnit.MILLISECONDS); if (!acquired.isEmpty()) { try { System.out.println("Thread-2 working with acquired resources..."); for (PooledResource resource : acquired) { resource.use(); } } finally { pool.releaseResources(acquired); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "Thread-2-Scan-DB"); Thread t3 = new Thread(() -> { try { Set<String> requested = new HashSet<>(Arrays.asList("Database", "Network", "Printer")); List<PooledResource> acquired = pool.acquireResources(requested, 3000, TimeUnit.MILLISECONDS); if (!acquired.isEmpty()) { try { System.out.println("Thread-3 working with acquired resources..."); for (PooledResource resource : acquired) { resource.use(); } } finally { pool.releaseResources(acquired); } } } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "Thread-3-All-Three"); t1.start(); t2.start(); t3.start(); t1.join(); t2.join(); t3.join(); System.out.println("Resource pool demo completed successfully"); } }

6. Best Practices & Patterns

Comprehensive Deadlock Prevention Strategy

public class DeadlockPreventionStrategies { // Strategy 1: Resource ordering public static class OrderedLocking { public static void acquireLocks(Object lock1, Object lock2) { // Determine order using hash code Object first, second; if (System.identityHashCode(lock1) < System.identityHashCode(lock2)) { first = lock1; second = lock2; } else { first = lock2; second = lock1; } synchronized (first) { synchronized (second) { // Critical section System.out.println(Thread.currentThread().getName() + " acquired both locks safely"); } } } } // Strategy 2: Try-lock with timeout public static class TimeoutLocking { public static boolean tryAcquireLocks(Object lock1, Object lock2, long timeoutMs) throws InterruptedException { long startTime = System.currentTimeMillis(); long remaining = timeoutMs; // Try to acquire first lock synchronized (lock1) { System.out.println(Thread.currentThread().getName() + " acquired first lock"); // Calculate remaining time long elapsed = System.currentTimeMillis() - startTime; remaining = timeoutMs - elapsed; if (remaining <= 0) { return false; // Timeout } // Try to acquire second lock with remaining time if (Thread.holdsLock(lock2)) { // Already have the lock (reentrant) return true; } // Use wait/notify to simulate try-lock with timeout long waitEnd = System.currentTimeMillis() + remaining; while (System.currentTimeMillis() < waitEnd) { try { lock2.wait(remaining); synchronized (lock2) { System.out.println(Thread.currentThread().getName() + " acquired second lock"); return true; } } catch (InterruptedException e) { Thread.currentThread().interrupt(); throw e; } } return false; // Timeout on second lock } } } // Strategy 3: Lock hierarchy validation public static class HierarchicalValidator { private static final ThreadLocal<Set<Object>> acquiredLocks = ThreadLocal.withInitial(HashSet::new); public static void validateLockOrder(Object lock) { Set<Object> currentLocks = acquiredLocks.get(); // Check if this lock violates any hierarchy for (Object acquiredLock : currentLocks) { if (System.identityHashCode(lock) < System.identityHashCode(acquiredLock)) { throw new IllegalStateException( "Lock order violation: trying to acquire " + lock + " after " + acquiredLock); } } currentLocks.add(lock); } public static void releaseLock(Object lock) { acquiredLocks.get().remove(lock); } public static void acquireWithValidation(Object lock1, Object lock2) { validateLockOrder(lock1); validateLockOrder(lock2); synchronized (lock1) { synchronized (lock2) { System.out.println(Thread.currentThread().getName() + " acquired locks with validation"); } } releaseLock(lock2); releaseLock(lock1); } } // Strategy 4: Resource allocation graph algorithm simulation public static class DeadlockDetector { private static final Map<Object, Set<Object>> allocationGraph = new ConcurrentHashMap<>(); private static final Object graphLock = new Object(); public static boolean wouldCauseDeadlock(Object requestedLock, Thread thread) { synchronized (graphLock) { // Simplified deadlock detection // In real implementation, you'd use proper graph cycle detection Set<Object> currentlyHeld = getLocksHeldByThread(thread); // Check if any thread holding the requested lock is waiting for locks we hold for (Object heldLock : currentlyHeld) { Set<Object> waitFor = allocationGraph.get(heldLock); if (waitFor != null && waitFor.contains(requestedLock)) { return true; // Potential deadlock detected } } return false; } } public static void recordAllocation(Object lock, Thread thread) { synchronized (graphLock) { allocationGraph.computeIfAbsent(lock, k -> new HashSet<>()) .addAll(getLocksHeldByThread(thread)); } } public static void recordRelease(Object lock) { synchronized (graphLock) { allocationGraph.remove(lock); } } private static Set<Object> getLocksHeldByThread(Thread thread) { // This is a simplified version // In real implementation, you'd track which locks each thread holds return Collections.emptySet(); } } public static void main(String[] args) throws InterruptedException { System.out.println("=== Comprehensive Deadlock Prevention ==="); Object lockA = new Object(); Object lockB = new Object(); Object lockC = new Object(); // Test Ordered Locking System.out.println("\n1. Testing Ordered Locking:"); Thread t1 = new Thread(() -> { OrderedLocking.acquireLocks(lockA, lockB); }, "Ordered-Thread"); t1.start(); t1.join(); // Test Timeout Locking System.out.println("\n2. Testing Timeout Locking:"); Thread t2 = new Thread(() -> { try { boolean success = TimeoutLocking.tryAcquireLocks(lockB, lockC, 1000); System.out.println("Timeout locking result: " + success); } catch (InterruptedException e) { Thread.currentThread().interrupt(); } }, "Timeout-Thread"); t2.start(); t2.join(); // Test Hierarchical Validation System.out.println("\n3. Testing Hierarchical Validation:"); Thread t3 = new Thread(() -> { try { HierarchicalValidator.acquireWithValidation(lockC, lockA); } catch (IllegalStateException e) { System.out.println("Validation caught: " + e.getMessage()); } }, "Validation-Thread"); t3.start(); t3.join(); System.out.println("\nAll prevention strategies demonstrated successfully"); } }

Key Prevention Strategies Summary

  1. Resource Ordering: Always acquire locks in a consistent global order
  2. Timeout Mechanisms: Use try-lock with timeout to avoid indefinite waiting
  3. Lock Hierarchy: Define and enforce a locking hierarchy
  4. Resource Pooling: Use managed resource pools with acquisition policies
  5. Deadlock Detection: Monitor and detect potential deadlocks at runtime
  6. Avoid Nested Locks: Design systems to minimize lock nesting when possible

Best Practices

  • Always use timeouts when acquiring multiple locks
  • Establish and follow a lock ordering convention
  • Use higher-level concurrency utilities from java.util.concurrent
  • Keep critical sections as small as possible
  • Test concurrent code thoroughly with stress tests
  • Monitor applications for potential deadlocks in production

Deadlock prevention requires careful design and consistent application of these strategies throughout your codebase.

Category : JAVA

Leave a Reply

Your email address will not be published. Required fields are marked *


Macro Nepal Helper