Java并发编程中死锁问题示例

原创末蓝、 2024-09-16 22:12 104阅读 0赞

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

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

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

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

@Override
    public void run() {
        synchronized (resourceA) { // 等待资源A释放
            synchronized (resourceB) { // 等待资源B释放
                System.out.println("Thread 1 is running and waiting for resources A and B.");
                try {
                    Thread.sleep(500); // 模拟等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

System.out.println("Thread 1 has finished waiting for resources.");
    }
}

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

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

@Override
    public void run() {
        synchronized (resourceB) { // 等待资源B释放
            synchronized (resourceC) { // 等待资源C释放
                System.out.println("Thread 2 is running and waiting for resources B and C.");
                try {
                    Thread.sleep(500); // 模拟等待
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

System.out.println("Thread 2 has finished waiting for resources.");
    }
}

// 创建两个线程并启动
Thread thread1 = new Thread(new Thread1(new Object(), new Object()))); // 线程1需要资源A和资源B
thread1.start();

Thread thread2 = new Thread(new Thread2(new Object(), new Object())))); // 线程2需要资源B和资源C
thread2.start();
```

在这个示例中，如果线程1等待资源B释放后立即获取资源A（反之亦然），而线程2等待资源C释放后立即获取资源B（反之亦然），那么两个线程就会陷入死锁。