从多线程角度看Java死锁：实例展示

原创小咪咪 2024-10-07 16:39 50阅读 0赞

在多线程环境下，Java中的死锁是指两个或更多的线程相互等待资源，而这些资源又被其他线程占用，从而导致所有线程都无法继续执行的现象。

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

```java
// 线程1需要资源A和B
class Thread1 extends Thread {
    private Object resourceA;
    private Object resourceB;

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

@Override
    public void run() {
        synchronized (resourceA) {
            synchronized (resourceB) {
                System.out.println("Thread 1 acquiring A and B");
                // 资源A被释放，线程等待资源B
                resourceA.notify();
                try {
                    System.out.println("Thread 1 waiting for B");
                    synchronized (resourceB) {
                        resourceB.wait();
                    }
                } catch (InterruptedException e) {
                    System.out.println("Interrupted while waiting for B: " + e.getMessage());
                }

// 资源B被释放，线程成功获取资源A和B
                System.out.println("Thread 1 acquiring both A and B");
            }
        }
    }
}

// 线程2需要资源B和C
class Thread2 extends Thread {
    private Object resourceB;
    private Object resourceC;

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

@Override
    public void run() {
        synchronized (resourceB) {
            synchronized (resourceC) {
                System.out.println("Thread 2 acquiring B and C");
                // 资源B被释放，线程等待资源C
                resourceB.notify();
                try {
                    System.out.println("Thread 2 waiting for C");
                    synchronized (resourceC) {
                        resourceC.wait();
                    }
                } catch (InterruptedException e) {
                    System.out.println("Interrupted while waiting for C: " + e.getMessage());
                }

// 资源C被释放，线程成功获取资源B和C
                System.out.println("Thread 2 acquiring both B and C");
            }
        }
    }
}

// 创建资源对象并启动线程
Object resourceA = new Object();
Object resourceB = new Object();
Object resourceC = new Object();

Thread1 thread1 = new Thread1(resourceA, resourceB));
thread1.start();

Thread2 thread2 = new Thread2(resourceB, resourceC));
thread2.start();
```

在这个例子中，线程1需要资源A和B，线程2需要资源B和C。如果线程1先获取到资源B并释放，而线程2此时还没有获取到资源B，那么线程2就会被阻塞，无法继续执行。这种情况下就形成了死锁。