Java并发编程：死锁现象实例展示

原创短命女 2024-11-21 12:06 46阅读 0赞

死锁是Java并发编程中的一种严重问题，当两个或多个并发进程在执行过程中因争夺资源而造成的一种相互等待的现象称为死锁。

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

```java
// 线程1，持有资源R1
class Thread1 extends Thread {
    private Object resourceR1;

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

@Override
    public void run() {
        synchronized (resourceR1) { // R1
            try {
                System.out.println("Thread 1 acquires R1");
                Thread.sleep(2000); // 休眠，模拟资源耗尽
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (resourceR2) { // R2
                if (resourceR1 != null) { // 先释放R1
                    System.out.println("Thread 1 releases R1");
                    resourceR1 = null;
                }
                System.out.println("Thread 1 acquires R2");
                resourceR2 = new Object(); // 获得R2
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 线程2，持有资源R2
class Thread2 extends Thread {
    private Object resourceR2;

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

@Override
    public void run() {
        synchronized (resourceR2) { // R2
            try {
                System.out.println("Thread 2 acquires R2");
                Thread.sleep(500); // 休眠，模拟资源耗尽
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            synchronized (resourceR1) { // R1
                if (resourceR2 != null) { // 先释放R2
                    System.out.println("Thread 2 releases R2");
                    resourceR2 = null;
                }
                System.out.println("Thread 2 acquires R1");
                resourceR1 = new Object(); // 获得R1
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1(new Object()); // 获取资源R1
        Thread2 thread2 = new Thread2(new Object()); // 获取资源R2

thread1.start(); // 启动线程1
        thread2.start(); // 启动线程2

try {
            // 线程等待直到所有资源都被释放
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，线程1持有资源R1，线程2持有资源R2。当线程1和线程2同时尝试获取对方的资源时（`resourceR1 = new Object()` 和 `resourceR2 = new Object()`），就会形成死锁。