多线程挑战：Java并发编程中的死锁示例？

原创逃离我推掉我的手 2024-10-27 23:00 36阅读 0赞

在Java并发编程中，死锁是一种常见的问题。当两个或更多的线程互相等待对方释放资源时，就会发生死锁。

以下是一个简单的Java代码示例，展示了如何创建并陷入死锁：

```java
// 创建两个互有依赖的线程
class ThreadA implements Runnable {
    private Object resourceA = new Object();

@Override
    public void run() {
        try {
            // 线程A需要资源B才能继续
            synchronized (resourceA) {
                System.out.println("Thread A acquires resource A");

// 现在线程A尝试获取资源B
                synchronized (ThreadB.resourceB) {
                    System.out.println("Thread A acquires resource B");

// 如果资源B已经被其他线程占用，就会导致死锁
                    if (ThreadB.isResourceBOccupied()) {
                        throw new InterruptedException("Deadlock occurred due to resource contention.");
                    }
                }

// 线程A释放资源B
                synchronized (ThreadB.resourceB) {
                    ThreadB.releaseResourceB();
                    System.out.println("Thread A releases resource B");
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadB implements Runnable {
    private Object resourceB = new Object();

private boolean isResourceBOccupied() {
        // 模拟资源B已经被其他线程占用
        return true;
    }

@Override
    public void run() {
        try {
            // 线程B需要资源A才能继续
            synchronized (ThreadA.resourceA) {
                System.out.println("Thread B acquires resource A");

// 如果资源A已经被其他线程占用，就会导致死锁
                if (ThreadA.isResourceAOccupied()) {
                    throw new InterruptedException("Deadlock occurred due to resource contention.");
                }
            }

// 线程B释放资源A
            synchronized (ThreadA.resourceA) {
                ThreadA.releaseResourceA();
                System.out.println("Thread B releases resource A");
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class DeadlockExample {
    public static void main(String[] args) {
        // 创建线程A和B
        ThreadA threadA = new ThreadA();
        ThreadB threadB = new ThreadB();

// 启动线程A和B
        new Thread(threadA).start();
        new Thread(threadB).start();
    }
}
```

在这个示例中，线程A需要资源B才能继续（`ThreadA.resourceA` 和 `ThreadB.resourceB`），同时线程B也需要资源A才能继续。这就导致了两个线程互相等待对方释放资源，从而陷入了死锁。