Java并发编程问题：死锁实例展示

原创心已赠人 2024-10-25 04:36 14阅读 0赞

死锁是并发编程中的一个重要问题。简单来说，如果两个或多个线程相互等待对方释放资源，但它们各自持有的资源又是完成工作必需的，那么就会形成死锁。

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

```java
// 线程1，持有资源A
class Thread1 extends Thread {
    private Object resourceA = new Object();

@Override
    public void run() {
        synchronized (resourceA) {
            // 资源A被占用，等待资源B
            System.out.println("Thread 1 waiting for resource B...");

try {
                // 等待资源B释放（这里假设资源B在Thread2中）
                resourceB = new Object();
                synchronized (resourceB) {
                    System.out.println("Thread 1 acquired resource B...");

// 当获得资源B后，释放资源A
                    resourceA.notifyAll();
                    synchronized (resourceA) {
                        System.out.println("Thread 1 released resource A...");
                        return;
                    }
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

private Object resourceB = new Object();

public Thread1() {
        super("Thread 1");
        start();
    }
}

// 线程2，持有资源B
class Thread2 extends Thread {
    private Object resourceB = new Object();

@Override
    public void run() {
        synchronized (resourceB) {
            System.out.println("Thread 2 acquired resource B...");

// 当获得资源B后，释放资源A
            resourceA = new Object();
            synchronized (resourceA) {
                System.out.println("Thread 2 released resource A...");
                resourceB.notifyAll();
            }
        }

while (true) {
            try {
                // 等待资源A被释放（这里假设资源A在Thread1中）
                synchronized (resourceA) {
                    System.out.println("Thread 2 waiting for resource A to be released...");

resourceA.wait();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

// 当资源A被释放后，重新获取资源B
            synchronized (resourceB) {
                System.out.println("Thread 2 acquired resource B again...");

resourceB.notifyAll();
            }
        }
    }

public Thread2() {
        super("Thread 2");
        start();
    }
}
```

在这个例子中，线程1持有资源A（初始化为`new Object()`）并等待资源B被释放。同理，线程2持有资源B并等待资源A被释放。

由于两个线程相互等待对方释放资源，导致它们都无法执行下去，从而形成了死锁。