多线程并发困惑：Java中的死锁案例

原创太过爱你忘了你带给我的痛 2024-09-23 03:06 49阅读 0赞

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

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

```java
// 线程1，获取资源A
class Thread1 extends Thread {
    private Object resourceA;

Thread1(Object resourceA) {
        this.resourceA = resourceA;
    }

@Override
    public void run() {
        synchronized (resourceA) {
            System.out.println("Thread 1: Acquiring A");

// 线程2，获取资源B
            Thread2 resourceB = new Thread2(resourceA);
            resourceB.start();

System.out.println("Thread 1: Holding A, waiting for B");

try {
                // 等待资源B释放
                resourceB.join();
                System.out.println("Thread 1: Received B, releasing A");
                synchronized (resourceA) {
                    resourceA.notifyAll();
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

}
    }

// 线程2，获取资源B
    class Thread2 extends Thread {
        private Object resourceB;

Thread2(Object resourceB) {
            this.resourceB = resourceB;
        }

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

// 线程1等待资源B释放
                try {
                    resourceA.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

System.out.println("Thread 2: Holding B, releasing A");
                synchronized (resourceA) {
                    resourceA.notifyAll();
                }
            }
        }
    }

public static void main(String[] args) {
        Object resourceA = new Object();
        Object resourceB = new Object();

Thread1 t1 = new Thread1(resourceA);
        Thread2 t2 = new Thread2(resourceB);

t1.start();
        t2.start();
    }
}
```

在这个例子中，线程1（Thread 1）获取资源A，并等待资源B。同时，线程2（Thread 2）获取资源B并释放资源A。

如果线程2先释放资源A，而线程1还没有得到资源B，那么就会出现死锁：线程1等待资源B，线程2等待资源A，它们互相等待对方释放资源。