Java多线程并发编程：死锁示例

原创太过爱你忘了你带给我的痛 2024-09-29 08:24 85阅读 0赞

在Java多线程并发编程中，死锁是一个常见的问题。简单来说，死锁是两个或更多线程在执行过程中，因争夺资源而造成的一种互相等待的现象，且每个线程都处于等待状态。

下面给出一个简单的死锁示例：

```java
// 线程1，需要资源A和B
public class Thread1 extends Thread {
    private Object resourceA, 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: Acquiring resources A and B");
                // 线程1获得资源后，会释放资源A，等待资源B
                resourceA.notify();
                try {
                    resourceB.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("Thread 1: Exiting after acquiring resources A and B");
    }
}

// 线程2，需要资源C和D
public class Thread2 extends Thread {
    private Object resourceC, resourceD;

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

@Override
    public void run() {
        synchronized (resourceC) {
            synchronized (resourceD) {
                System.out.println("Thread 2: Acquiring resources C and D");
                // 线程2获得资源后，会释放资源C，等待资源D
                resourceC.notify();
                try {
                    resourceD.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
        System.out.println("Thread 2: Exiting after acquiring resources C and D");
    }
}

// 主程序
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();

try {
            // 等待所有线程完成
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("All threads have completed their tasks.");
    }
}
```

这个示例中，两个线程分别需要资源A和B（Thread 1），以及资源C和D（Thread 2）。开始时，每个线程都会等待其所需的全部资源。这就导致了死锁：两个线程互相等待对方释放资源。

在实际应用中，避免死锁的策略包括资源的静态分配、设置超时机制、使用死锁预防算法等。