Java多线程并发问题：死锁演示

原创待我称王封你为后i 2024-12-06 23:48 44阅读 0赞

在Java多线程编程中，死锁是一个非常重要的并发问题。简单来说，死锁就是两个或更多的线程互相等待对方释放资源，从而导致所有线程都无法继续执行的情况。

下面是一个简单的Java死锁示例：

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

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

@Override
    public void run() {
        synchronized (resourceA) {
            synchronized (resourceB) {
                System.out.println("Thread 1 started acquiring resources");

// 线程1尝试获取资源，但资源已被其他线程占有
                try {
                    resourceA.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

System.out.println("Thread 1 acquired resource A");

// 同理，线程1无法立即获取到资源B
                try {
                    resourceB.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

System.out.println("Thread 1 acquired resource B");

// 现在，资源A和资源B都已被线程1获得

// 此时线程2请求资源A，但由于资源已经被线程1占用，无法立即获取
                synchronized (resourceA) {
                    System.out.println("Thread 2 tried to acquire resource A but failed");

// 线程1释放资源A，这样线程2才能获取到资源
                    resourceA.notify();
                }
            }
        }
    }
}

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

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

@Override
    public void run() {
        synchronized (resourceB) {
            System.out.println("Thread 2 started acquiring resources");

// 线程1释放资源B，这样线程2才能获取到资源
            resourceB.notify();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1(new Object(), new Object()));
        Thread2 thread2 = new Thread2(new Object(), new Object()));

thread1.start();
        thread2.start();
    }
}
```

在这个示例中，线程1需要资源A和B，而线程2需要资源B和C。当两个线程同时请求一个资源且该资源已经被其他线程占用时，就会发生死锁。

要避免死锁，可以遵循"预防原则"，即在多线程编程中，避免出现会导致死锁的并发条件。例如，在上述示例中，如果线程1先获取到资源B再尝试获取资源A，或者线程2先获取到资源C再尝试获取资源B，那么就可以避免死锁的发生。