Java并发编程中的死锁现象：一个实战案例

原创 ╰+攻爆jí腚メ 2024-10-14 08:18 44阅读 0赞

在Java并发编程中，死锁是一个非常关键且常见的问题。简单来说，死锁就是两个或多个线程互相等待对方释放资源，而这种状态无法自行打破，从而导致程序僵化。

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

```java
// 定义资源
class Resource {
    int count;
    Resource(int count) { this.count = count; }
}

// 定义线程
class ThreadA extends Thread {
    Resource resA;

ThreadA(Resource resA) {
        this.resA = resA;
    }

@Override
    public void run() {
        try {
            System.out.println("Thread A acquire resource A");

// 线程A需要资源A和资源B
            if (resA.count >= 2) {
                resA.count -= 2;
                ThreadB resB = new ThreadB(resA);
                resB.start();
            } else {
                // 资源不足，线程A等待
                while (!resA.count) {
                    System.out.println("Thread A wait resource A");
                    try {
                        Thread.sleep(1000);  // 线程休眠
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }

System.out.println("Thread A release resource A");

} catch (Exception e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread {
    Resource resA;

ThreadB(Resource resA) {
        this.resA = resA;
    }

@Override
    public void run() {
        try {
            System.out.println("Thread B acquire resource A");

// 资源A被线程A占用，线程B等待
            while (!resA.count) {
                System.out.println("Thread B wait resource A");
                try {
                    Thread.sleep(1000);  // 线程休眠
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

System.out.println("Thread B release resource A");

} catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Resource resA = new Resource(2);
        ThreadA threadA = new ThreadA(resA);
        threadA.start();

Resource resB = new Resource(1);
        ThreadB threadB = new ThreadB(resB);
        threadB.start();
    }
}
```

在这个例子中，两个线程（ThreadA和ThreadB）在资源有限的情况下进行交互。当ThreadA需要资源A和资源B时，由于资源A的限制，ThreadA必须等待资源A释放。同样，当ThreadB获取资源B后，它也需要资源A，而此时资源A已被ThreadA占用，导致死锁。