Java的死锁

死锁（Deadlock）是多线程或多进程环境中的一种特定状况，当中涉及的线程或进程都在等待某个资源，但是这些资源又被这些线程或进程中的其他成员所持有，从而导致了无限期的等待，因此所有的线程或进程都无法向前推进执行。

死锁的四个必要条件

1. 互斥条件 (Mutual Exclusion): 至少有一个资源必须处于非共享模式，即一次只有一个进程可以使用。如果另一个进程请求该资源，请求者只能等待，直到资源被释放。

2. 持有和等待 (Hold and Wait): 一个进程至少持有一个资源，并且正在等待获取额外的资源，而这些资源又被其他进程持有。

3. 非抢占条件 (No Preemption): 资源只能由持有它们的进程在完成任务后自愿释放，不能被强制夺取。

4. 循环等待 (Circular Wait): 发生死锁时，必须存在一个进程-资源的循环链，每个进程至少持有一个资源，并等待获取下一个进程所持有的资源。

死锁的例子

假设有两个线程（A和B）和两个资源（X和Y）。

1. 线程A持有资源X并请求资源Y。
2. 同时，线程B持有资源Y并请求资源X。
3. 这时，线程A和B都在等待对方释放资源，但是它们都不会放弃自己已经持有的资源。
4. 结果，两个线程都无法继续执行，发生了死锁。

死锁的处理

对于死锁，可以采取以下几种策略：

• 预防：通过破坏死锁的四个必要条件中的一个或多个来预防死锁的发生。

• 避免：在运行时避免系统进入不安全状态。银行家算法是一种著名的避免死锁的算法。

• 检测和恢复：允许死锁发生，但是你需要有检测机制来检测死锁的发生，并采取措施来恢复。

• 忽略：这种策略在编写代码时不考虑死锁（“鸵鸟算法”），仅在用户级别处理死锁。这通常是操作系统中采用的策略，因为死锁发生的频率很低，且死锁预防和恢复的成本可能很高。

为了避免或预防死锁，可以使用以下一些技术：

• 锁定顺序：确保所有线程以相同的顺序请求资源。
• 锁超时：线程在请求资源时使用超时，如果不能获取所有资源，则释放已获得的资源并重试。
• 资源分配图：分析系统的资源分配图，检测循环等待条件是否成立。
• 事务和锁的设计：在数据库系统中，通过使用事务、锁和隔离级别来确保并发操作的正确性。

死锁是并发编程中必须认真对待的问题，因为它可能导致应用程序完全停止响应。在设计系统时，应该考虑并发控制策略，以减少或消除死锁的风险。




 

通过模拟一个简单的Java程序来展示死锁的情况。在这个例子中，我们将有两个线程和两个共享资源，每个线程都会尝试锁定两个资源中的一个，然后尝试锁定另一个，如果不小心编程，这可能会导致死锁。

假设我们有两个资源，分别是Resource1和Resource2：

public class Resource1 {
    public synchronized void test1(Resource2 resource2) {
        System.out.println(Thread.currentThread().getName() + " acquired lock on Resource1");

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " trying to acquire lock on Resource2");
        resource2.test2();
    }

    public synchronized void test2() {
        System.out.println(Thread.currentThread().getName() + " acquired lock on Resource1");
    }
}

public class Resource2 {
    public synchronized void test1(Resource1 resource1) {
        System.out.println(Thread.currentThread().getName() + " acquired lock on Resource2");

        try {
            Thread.sleep(100);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        System.out.println(Thread.currentThread().getName() + " trying to acquire lock on Resource1");
        resource1.test2();
    }

    public synchronized void test2() {
        System.out.println(Thread.currentThread().getName() + " acquired lock on Resource2");
    }
}

现在，让我们创建两个线程，它们将尝试以相反的顺序获取两个资源的锁，这可能会导致死锁：

public class DeadlockDemo {
    public static void main(String[] args) {
        final Resource1 resource1 = new Resource1();
        final Resource2 resource2 = new Resource2();

        // Thread 1 tries to lock Resource1 then Resource2
        Thread t1 = new Thread(() -> {
            resource1.test1(resource2);
        }, "Thread 1");

        // Thread 2 tries to lock Resource2 then Resource1
        Thread t2 = new Thread(() -> {
            resource2.test1(resource1);
        }, "Thread 2");

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

运行结果：

在上面的代码中，t1 和 t2 是两个线程，它们都试图首先锁定一个资源，然后再锁定另一个资源。如果 t1 锁定了 resource1 并且 t2 锁定了 resource2，它们都会试图去锁定对方已经持有的资源。因为 synchronized 方法会在对象上持有锁，直到方法完成，所以每个线程都会等待对方释放资源，而没有一个线程愿意放弃它已经持有的锁。这就是死锁的情况。

在实际情况中，避免死锁通常涉及确保所有线程以相同的顺序请求资源，或者使用更复杂的并发控制机制，比如 java.util.concurrent 包中的 Lock 接口和相关实现，它们提供了超时和尝试锁定的能力，从而可以避免死锁。