深入理解Java多线程：死锁案例探讨

原创ゞ浴缸里的玫瑰 2024-11-25 23:24 18阅读 0赞

在Java编程中，多线程是一个重要的概念。然而，多线程也会带来一些问题，如并发控制不当可能导致的死锁。

**什么是死锁？**

死锁是指两个或更多的线程在执行过程中因争夺资源而造成的一种互相等待的现象，若无外力干涉，它们都将无法继续执行。

**Java中死锁案例：**

1. **银行家算法中的例子**：

假设有两个窗口（A和B），每个窗口都有一张银行卡（卡A和卡B）。

窗口A的卡B是B窗口的卡A，这就形成了一个死锁状态。因为两个窗口都在等待对方释放资源。

2. **代码示例**：

```java
// 假设两个线程，每个线程持有资源1和2

class ThreadA extends Thread {
    ResourceA r1, r2;

ThreadA(ResourceA r1, ResourceA r2) {
        this.r1 = r1;
        this.r2 = r2;
    }

@Override
    public void run() {
        // 线程A持有资源1和2
        // 同时等待资源2被释放

if (r1.is占有 && !r2.is占有) {
            // 此刻资源2未释放，线程A无法执行下一步
            r1.lock();
            System.out.println("Thread A acquired resource 1");
            try {
                // 等待资源2释放
                while (!r2.is占有)) {
                    Thread.sleep(100); // 模拟等待时间
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread A released resource 1");
            r2.lock(); // 同时获取资源2，解锁资源1
            System.out.println("Thread A acquired resource 2");
        }
    }
}

class ThreadB extends Thread {
    ResourceB r1, r2;

ThreadB(ResourceB r1, ResourceB r2)) {
        this.r1 = r1;
        this.r2 = r2;
    }

@Override
    public void run() {
        // 线程B持有资源1和2
        // 同时等待资源1被释放

if (r2.is占有 && !r1.is占有)) {
            // 此刻资源1未释放，线程B无法执行下一步
            r2.lock();
            System.out.println("Thread B acquired resource 2");
            try {
                // 等待资源1释放
                while (!r1.is占有)) {
                    Thread.sleep(100); // 模拟等待时间
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Thread B released resource 2");
            r1.lock(); // 同时获取资源1，解锁资源2
            System.out.println("Thread B acquired resource 1");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ResourceA r1 = new ResourceA();
        ResourceB r2 = new ResourceB();

ThreadA ta1 = new ThreadA(r1, r2));
        ThreadB tb1 = new ThreadB(r1, r2));

ta1.start();
        tb1.start();
    }
}
```

这个例子展示了两个线程（Thread A和Thread B）同时持有资源1和2。由于每个线程都在等待对方释放资源，导致了死锁的产生。