Java 手写死锁并解决死锁

在多线程编程中，死锁是一个常见而又严峻的问题。当两个或多个线程在等待彼此释放资源时，程序将进入一种无法继续执行的状态。本文将通过手写代码实现简单的死锁场景，并提供解决死锁的方法。

死锁的示例

在Java中，可以通过两个互相持有对方锁的线程实现死锁。以下是一个简单的死锁示例：

public class DeadLockExample {

    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    // Thread 1 tries to acquire lock1 then lock2
    public static void thread1() {
        synchronized (lock1) {
            System.out.println("Thread 1: Holding lock 1...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Thread 1: Waiting for lock 2...");
            synchronized (lock2) {
                System.out.println("Thread 1: Acquired lock 2!");
            }
        }
    }

    // Thread 2 tries to acquire lock2 then lock1
    public static void thread2() {
        synchronized (lock2) {
            System.out.println("Thread 2: Holding lock 2...");
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            System.out.println("Thread 2: Waiting for lock 1...");
            synchronized (lock1) {
                System.out.println("Thread 2: Acquired lock 1!");
            }
        }
    }

    public static void main(String[] args) {
        new Thread(DeadLockExample::thread1).start();
        new Thread(DeadLockExample::thread2).start();
    }
}

程序分析

在上面的代码中，两个线程试图分别获得 lock1 和 lock2。线程1持有 lock1 并等待 lock2，线程2则持有 lock2 并等待 lock1。由于它们互相等待，导致程序进入死锁状态，不能继续执行。

死锁的甘特图

以下是该死锁情况的甘特图，通过mermaid语法描述：

gantt
    title Deadlock Scenario
    dateFormat  HH:mm
    section Thread 1
    Acquire lock 1    :done,  des1, 00:00, 00:03
    Waiting for lock 2 :active, des2, 00:03, 00:06
    section Thread 2
    Acquire lock 2    :done,  des3, 00:00, 00:03
    Waiting for lock 1 :active, des4, 00:03, 00:06

解决死锁的方法

解决死锁的一个普遍策略是遵循锁的请求顺序，以确保不会形成循环等待的状况。以下是解决死锁的修改示例：

public class DeadLockResolution {

    private static final Object lock1 = new Object();
    private static final Object lock2 = new Object();

    // A method to acquire locks in a fixed order
    private static void acquireLocks(Object firstLock, Object secondLock) {
        synchronized (firstLock) {
            System.out.println(Thread.currentThread().getName() + ": Holding " + firstLock);
            try { Thread.sleep(100); } catch (InterruptedException e) {}
            synchronized (secondLock) {
                System.out.println(Thread.currentThread().getName() + ": Acquired " + secondLock);
            }
        }
    }

    public static void main(String[] args) {
        new Thread(() -> acquireLocks(lock1, lock2), "Thread 1").start();
        new Thread(() -> acquireLocks(lock2, lock1), "Thread 2").start(); // This will now work
    }
}

程序分析

在上述修改后的代码中，我们定义了一个方法 acquireLocks，它确保在请求锁时遵循固定的顺序。这样，两个线程都优先请求 lock1，从而避免了死锁的发生。

死锁的关系图

为了更好地理解死锁的关系，可以通过mermaid语法生成以下关系图：

erDiagram
    THREAD {
        string name
    }
    LOCK {
        string lockID
    }
    THREAD ||--o{ LOCK : holds
    THREAD ||--o{ LOCK : waits

这个关系图表达了线程与锁之间的关系，其中线程可以持有锁，也可以等待获取锁。

结论

死锁是多线程编程中必须认真对待的一个问题。虽然并发的程序设计能够提高效率，但控制好锁的使用顺序是至关重要的。总之，通过明确的锁请求顺序和合理的锁管理，可以有效避免死锁的发生。编写并发代码时，务必牢记这些原则，以确保程序的稳定性和可维护性。