Deadlocks in Java

public class DeadlockDemo {
    private static final Object lockA = new Object();
    private static final Object lockB = new Object();

    public static void main(String[] args) {

        Thread thread1 = new Thread(() -> {
            synchronized (lockA) {
                System.out.println("Thread-1: Holding Lock-A");
                try { Thread.sleep(50); } catch (InterruptedException e) {}

                System.out.println("Thread-1: Waiting for Lock-B...");
                synchronized (lockB) {
                    System.out.println("Thread-1: Holding Lock-A and Lock-B");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("Thread-2: Holding Lock-B");
                try { Thread.sleep(50); } catch (InterruptedException e) {}

                System.out.println("Thread-2: Waiting for Lock-A...");
                synchronized (lockA) {
                    System.out.println("Thread-2: Holding Lock-B and Lock-A");
                }
            }
        });

        thread1.start();
        thread2.start();
    }
}

// BEFORE: Deadlock-prone — different order in each thread
// Thread-1: lockA → lockB
// Thread-2: lockB → lockA

// AFTER: Safe — same order everywhere
// Thread-1: lockA → lockB
// Thread-2: lockA → lockB (same order!)

public void transfer(Account from, Account to, double amount) {
    Account first = from.getId() < to.getId() ? from : to;
    Account second = from.getId() < to.getId() ? to : from;

    synchronized (first) {
        synchronized (second) {
            from.debit(amount);
            to.credit(amount);
        }
    }
}

private static final ReentrantLock lockA = new ReentrantLock();
private static final ReentrantLock lockB = new ReentrantLock();

public void safeMethod() {
    boolean gotBothLocks = false;
    while (!gotBothLocks) {
        boolean gotA = false;
        boolean gotB = false;
        try {
            gotA = lockA.tryLock(100, TimeUnit.MILLISECONDS);
            gotB = lockB.tryLock(100, TimeUnit.MILLISECONDS);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        } finally {
            if (gotA && gotB) {
                gotBothLocks = true;
                try {
                    // do work
                } finally {
                    lockA.unlock();
                    lockB.unlock();
                }
            } else {
                if (gotA) lockA.unlock();
                if (gotB) lockB.unlock();
                // back off and retry
            }
        }
    }
}

public class MultiLock {
    public static void lockAll(Lock... locks) {
        while (true) {
            boolean allAcquired = true;
            for (Lock lock : locks) {
                if (!lock.tryLock()) {
                    allAcquired = false;
                    break;
                }
            }
            if (allAcquired) return;
            // release any acquired locks and retry
            for (Lock lock : locks) {
                try { lock.unlock(); } catch (IllegalMonitorStateException ignored) {}
            }
        }
    }
}

// Instead of manual synchronization, use concurrent collections
ConcurrentHashMap<String, Integer> map = new ConcurrentHashMap<>();
map.compute("key", (k, v) -> (v == null) ? 1 : v + 1);  // atomic

// Instead of shared mutable state, use message passing
BlockingQueue<Task> queue = new LinkedBlockingQueue<>();
queue.put(task);      // producer
Task t = queue.take(); // consumer

ThreadMXBean bean = ManagementFactory.getThreadMXBean();
long[] deadlockedThreads = bean.findDeadlockedThreads();

if (deadlockedThreads != null) {
    ThreadInfo[] infos = bean.getThreadInfo(deadlockedThreads);
    for (ThreadInfo info : infos) {
        System.out.println("Deadlocked thread: " + info.getThreadName());
        System.out.println("Waiting for lock: " + info.getLockName());
        System.out.println("Held by: " + info.getLockOwnerName());
    }
}