Java Deadlock — Lock Ordering Failures in Payment Systems

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); }
}

// io.thecodeforge
import java.util.concurrent.locks.ReentrantLock;
import java.util.concurrent.TimeUnit;

public class DeadlockBreaker {
    private final ReentrantLock lockA = new ReentrantLock();
    private final ReentrantLock lockB = new ReentrantLock();

    public void threadOne() {
        try {
            if (lockA.tryLock(2, TimeUnit.SECONDS)) {
                try {
                    // Simulate work
                    if (lockB.tryLock(2, TimeUnit.SECONDS)) {
                        try {
                            System.out.println("Thread 1: Got both locks");
                        } finally {
                            lockB.unlock();
                        }
                    } else {
                        System.out.println("Thread 1: Could not get lock B, releasing lock A");
                    }
                } finally {
                    lockA.unlock();
                }
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
    }

    // threadTwo() mirrors threadOne but uses same lock order
}

// io.thecodeforge
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;

public class LiveLockDetector {
    private final ReentrantLock lockA = new ReentrantLock();
    private final ReentrantLock lockB = new ReentrantLock();
    private final AtomicInteger retryCount = new AtomicInteger(0);

    public void workWithBackoff() {
        while (true) {
            if (lockA.tryLock()) {
                try {
                    if (lockB.tryLock()) {
                        try {
                            System.out.println("Work done after retries: " + retryCount.get());
                            return;
                        } finally {
                            lockB.unlock();
                        }
                    }
                } finally {
                    lockA.unlock();
                }
            }
            // Exponential backoff: 10ms, 20ms, 40ms, ...
            long backoff = Math.min(100, 10 * (1 << retryCount.getAndIncrement()));
            try {
                Thread.sleep(backoff + (long)(Math.random() * backoff));
            } catch (InterruptedException e) {
                Thread.currentThread().interrupt();
                return;
            }
        }
    }
}

// io.thecodeforge
import java.lang.management.ManagementFactory;
import java.lang.management.ThreadMXBean;
import java.util.concurrent.CountDownLatch;

public class DeadlockStressTest {
    private static final Object resourceA = new Object();
    private static final Object resourceB = new Object();

    public void runStressTest() throws InterruptedException {
        ThreadMXBean bean = ManagementFactory.getThreadMXBean();
        CountDownLatch latch = new CountDownLatch(1);
        
        Runnable task1 = () -> {
            synchronized(resourceA) {
                try { Thread.sleep(1); } catch (InterruptedException e) {}
                synchronized(resourceB) {}
            }
        };
        
        Runnable task2 = () -> {
            synchronized(resourceB) {
                try { Thread.sleep(1); } catch (InterruptedException e) {}
                synchronized(resourceA) {}
            }
        };
        
        for (int i = 0; i < 50; i++) {
            new Thread(task1).start();
            new Thread(task2).start();
        }
        
        Thread.sleep(5000);
        long[] deadlockedIds = bean.findDeadlockedThreads();
        if (deadlockedIds != null) {
            throw new RuntimeException("Deadlock detected! Threads: " + deadlockedIds.length);
        }
        System.out.println("No deadlock — stress test passed");
    }
}