Java多线程并发编程：死锁案例分析

原创朱雀 2024-09-20 01:30 122阅读 0赞

在Java多线程编程中，死锁是一种严重的并发问题。当两个或更多的线程在执行过程中因争夺资源而造成的一种互相等待的现象称为死锁。

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

```java
// 线程类
class ThreadA extends Thread {
    private Object resourceA;
    ThreadA(Object resourceA) {
        this.resourceA = resourceA;
    }
    public void run() {
        while (true) { // 无限循环
            synchronized (resourceA) {
                if (conditionA()) { // 条件A满足，获取资源
                    System.out.println("Thread A acquires " + resourceA);
                    break; // 资源已获取，跳出循环
                }
            }
        }
    }
}

class ThreadB extends Thread {
    private Object resourceB;
    ThreadB(Object resourceB) {
        this.resourceB = resourceB;
    }
    public void run() {
        while (true) { // 无限循环
            synchronized (resourceB) {
                if (conditionB()) { // 条件B满足，获取资源
                    System.out.println("Thread B acquires " + resourceB);
                    break; // 资源已获取，跳出循环
                }
            }
        }
    }
}

// 主程序
public class Main {
    private Object resourceA;
    private Object resourceB;

public Main() {
        resourceA = new Object();
        resourceB = new Object();
    }

public void startThreads() {
        ThreadA threadA = new ThreadA(resourceA);
        ThreadB threadB = new ThreadB(resourceB);

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

public static void main(String[] args) {
        Main main = new Main();
        main.startThreads(); // 开始多线程操作
    }
}

```

在这个例子中，ThreadA和ThreadB都尝试获取两个资源：resourceA和resourceB。但是每个线程都会无限循环地等待对方释放资源。

当两个线程按照如下顺序执行（例如ThreadA先获取资源然后释放，接着ThreadB获取资源）：

1. ThreadA 获取 resourceA
2. ThreadA 释放 resourceA (允许 ThreadB 获取)
3. ThreadB 获取 resourceB
4. ThreadB 释放 resourceB (允许 ThreadA 获取)

这样就避免了死锁的发生。