Java并发编程：如何避免死锁问题实例

原创青旅半醒 2024-10-23 17:57 19阅读 0赞

死锁是多线程编程中常见的问题，当两个或更多线程因争夺资源而造成的一种互相等待的现象时，就会发生死锁。

以下是一个简单的Java死锁实例：

```java
// 线程A
public class ThreadA extends Thread {
    private Object lockA = new Object();

public void run() {
        try {
            // 获取锁A
            synchronized (lockA) {
                System.out.println("Thread A: Acquiring lock A...");

// 在获取锁后，执行耗时操作
                Thread.sleep(2000); // 模拟耗时操作

System.out.println("Thread A: Lock A acquired, releasing lock B...");

// 释放锁A
                synchronized (lockA) {
                    lockA.notifyAll();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 线程B
public class ThreadB extends Thread {
    private Object lockB = new Object();

public void run() {
        try {
            // 获取锁B
            synchronized (lockB) {
                System.out.println("Thread B: Acquiring lock B...");

// 在获取锁后，执行耗时操作
                Thread.sleep(2000); // 模拟耗时操作

System.out.println("Thread B: Lock B acquired, releasing lock A...");

// 释放锁B
                synchronized (lockB) {
                    lockB.notifyAll();
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();

// 启动线程
        threadA.start();
        threadB.start();

try {
            // 等待所有线程执行完毕
            threadA.join();
            threadB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，ThreadA持有锁A，而ThreadB持有锁B。如果ThreadA等待获取LockB（因为锁B被ThreadB持有），而ThreadB等待获取LockA（因为锁A被ThreadA持有），那么就会形成死锁。

要避免死锁，可以遵循以下几个原则：

1. 互斥：一个资源一次只能被一个进程访问。
2. 不剥夺：进程一旦获得资源，就不能被迫放弃。
3. 请求和释放循环的终止条件：在一个进程序列中，不存在这样的进程顺序，即它们按这种方式无限地相互等待对方所占有的资源。