Deadlock in Java — Causes and Prevention

package io.thecodeforge.concurrency;

/**
 * io.thecodeforge: Classic Deadlock Scenario
 * Demonstrates circular wait between two resources.
 */
public class DeadlockDemo {
    private static final Object Lock1 = new Object();
    private static final Object Lock2 = new Object();

    public static void main(String[] args) {
        Thread t1 = new Thread(() -> {
            synchronized (Lock1) {
                System.out.println("Thread 1: Holding Lock 1...");
                try { 
                    // Simulate some processing to ensure t2 grabs Lock2
                    Thread.sleep(100); 
                } catch (InterruptedException e) { 
                    Thread.currentThread().interrupt(); 
                }
                System.out.println("Thread 1: Waiting for Lock 2...");
                synchronized (Lock2) {
                    System.out.println("Thread 1: Holding Lock 1 & 2");
                }
            }
        }, "Forge-Thread-1");

        Thread t2 = new Thread(() -> {
            synchronized (Lock2) {
                System.out.println("Thread 2: Holding Lock 2...");
                try { 
                    Thread.sleep(100); 
                } catch (InterruptedException e) { 
                    Thread.currentThread().interrupt(); 
                }
                System.out.println("Thread 2: Waiting for Lock 1...");
                synchronized (Lock1) {
                    System.out.println("Thread 2: Holding Lock 1 & 2");
                }
            }
        }, "Forge-Thread-2");

        t1.start();
        t2.start();
    }
}

package io.thecodeforge.concurrency;

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

/**
 * io.thecodeforge: Preventing Deadlock using tryLock with timeout.
 * This implementation breaks the 'Hold and Wait' condition.
 */
public class SafeLocking {
    private final Lock lockA = new ReentrantLock();
    private final Lock lockB = new ReentrantLock();

    public void performSafeTransfer() throws InterruptedException {
        boolean gotLockA = false;
        boolean gotLockB = false;

        try {
            // Attempt to acquire both locks within a specific timeframe
            gotLockA = lockA.tryLock(500, TimeUnit.MILLISECONDS);
            gotLockB = lockB.tryLock(500, TimeUnit.MILLISECONDS);

            if (gotLockA && gotLockB) {
                System.out.println("Resources acquired safely - Proceeding with Forge logic");
                // Perform critical section work here
            } else {
                System.out.println("Could not acquire locks safely. Backing off to prevent deadlock.");
            }
        } finally {
            // Ensure locks are always released in the finally block
            if (gotLockA) lockA.unlock();
            if (gotLockB) lockB.unlock();
        }
    }
}