Java Deadlock — Lock Ordering Failures in Payment Systems

package io.thecodeforge.concurrent;

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("Thread1: acquired lockA");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (lockB) {
                    System.out.println("Thread1: acquired lockB");
                }
            }
        });

        Thread thread2 = new Thread(() -> {
            synchronized (lockB) {
                System.out.println("Thread2: acquired lockB");
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (lockA) {
                    System.out.println("Thread2: acquired lockA");
                }
            }
        });

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

package io.thecodeforge.concurrent;

// Pseudocode: verify all four conditions are present
public class ConditionCheck {
    boolean mutualExclusion = true;   // lock is exclusive
    boolean holdAndWait = true;       // threads hold one lock while waiting for another
    boolean noPreemption = true;      // lock can't be taken from thread
    boolean circularWait = true;      // A waits for B, B waits for A

    public boolean isDeadlock() {
        return mutualExclusion && holdAndWait && noPreemption && circularWait;
    }
}

package io.thecodeforge.concurrent;

import java.lang.management.ManagementFactory;
import java.lang.management.ThreadInfo;
import java.lang.management.ThreadMXBean;

public class DeadlockDetector {
    private final ThreadMXBean bean = ManagementFactory.getThreadMXBean();

    public void detectDeadlocks() {
        long[] deadlockedIds = bean.findMonitorDeadlockedThreads();
        if (deadlockedIds == null) {
            System.out.println("No deadlock detected.");
            return;
        }

        ThreadInfo[] infos = bean.getThreadInfo(deadlockedIds);
        for (ThreadInfo info : infos) {
            System.err.printf("DEADLOCK DETECTED: Thread %s (id=%d) holds %s and waits for %s%n",
                    info.getThreadName(), info.getThreadId(),
                    info.getLockName(), info.getLockOwnerName());
        }
        // Alert on-call or trigger thread dump
    }

    public static void main(String[] args) throws InterruptedException {
        // Simulate deadlock with ABBA pattern
        Object lock1 = new Object();
        Object lock2 = new Object();

        Thread t1 = new Thread(() -> {
            synchronized (lock1) {
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (lock2) {}
            }
        });
        Thread t2 = new Thread(() -> {
            synchronized (lock2) {
                try { Thread.sleep(100); } catch (InterruptedException e) {}
                synchronized (lock1) {}
            }
        });
        t1.start(); t2.start();
        Thread.sleep(500);
        new DeadlockDetector().detectDeadlocks();
    }
}

package io.thecodeforge.concurrent;

public class ReproduceDeadlock {
    private static final Object resA = new Object();
    private static final Object resB = new Object();

    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            synchronized (resA) {
                System.out.println(Thread.currentThread().getName() + " locked resA");
                sleep(100); // force timing to ensure deadlock
                synchronized (resB) {
                    System.out.println(Thread.currentThread().getName() + " locked resB");
                }
            }
        }, "Worker-1");

        Thread t2 = new Thread(() -> {
            synchronized (resB) {
                System.out.println(Thread.currentThread().getName() + " locked resB");
                sleep(100);
                synchronized (resA) {
                    System.out.println(Thread.currentThread().getName() + " locked resA");
                }
            }
        }, "Worker-2");

        t1.start(); t2.start();
        t1.join(); t2.join(); // never returns due to deadlock
    }

    private static void sleep(long ms) {
        try { Thread.sleep(ms); } catch (InterruptedException e) { Thread.currentThread().interrupt(); }
    }
}

package io.thecodeforge.concurrent;

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

public class SafeTransfer {
    private final Lock lock = new ReentrantLock();
    private long balance;

    // Lock ordering: always lock accounts in account ID order
    public boolean transfer(SafeTransfer to, long amount) {
        SafeTransfer first = this.id() < to.id() ? this : to;
        SafeTransfer second = this.id() < to.id() ? to : this;

        first.lock.lock();
        try {
            second.lock.lock();
            try {
                if (this.balance < amount) return false;
                this.balance -= amount;
                to.balance += amount;
                return true;
            } finally {
                second.lock.unlock();
            }
        } finally {
            first.lock.unlock();
        }
    }

    // Alternative using tryLock with timeout
    public boolean transferWithTimeout(SafeTransfer to, long amount, long timeout, TimeUnit unit) throws InterruptedException {
        if (!this.lock.tryLock(timeout, unit)) return false;
        try {
            if (!to.lock.tryLock(timeout, unit)) {
                return false; // release and reacquire is possible but not shown for brevity
            }
            try {
                if (this.balance < amount) return false;
                this.balance -= amount;
                to.balance += amount;
                return true;
            } finally {
                to.lock.unlock();
            }
        } finally {
            this.lock.unlock();
        }
    }

    private long id() { return System.identityHashCode(this); }
}