Java并发编程：死锁示例

原创痛定思痛。 2024-09-18 03:36 101阅读 0赞

死锁是多线程并发编程中的一种严重问题，当一个或多个线程因等待其他线程释放已获得的资源而造成的一种相互“僵持”的状态时，就可能发生死锁。

下面是一个经典的死锁示例（使用Java Swing库）：

```java
import javax.swing.*;
import java.awt.*;

public class DeadLockExample {

private static final int PANEL_WIDTH = 400;
    private static final int PANEL_HEIGHT = 300;

public static void main(String[] args) {
        EventQueue.invokeLater(() -> {
            try {
                // 创建窗体和布局
                JFrame frame = new JFrame("Dead Lock Example");
                frame.setSize(PANEL_WIDTH, PANEL_HEIGHT);
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

// 创建线程，模拟资源和请求
                Thread thread1 = new Thread(() -> {
                    JLabel label1 = new JLabel("Resource 1");
                    frame.add(label1, BorderLayout.NORTH);

try {
                        // 模拟等待资源
                        synchronized (label1) {
                            label1.setText("Waiting for Resource 1...");
                            label1.notify();
                        }
                    } catch (Exception e) {
                        System.out.println("Error occurred: " + e.getMessage());
                    }
                }));

Thread thread2 = new Thread(() -> {
                    JLabel label2 = new JLabel("Resource 2");
                    frame.add(label2, BorderLayout.CENTER);

try {
                        // 模拟等待资源
                        synchronized (label2) {
                            label2.setText("Waiting for Resource 2...");
                            label2.notify();
                        }
                    } catch (Exception e) {
                        System.out.println("Error occurred: " + e.getMessage());
                    }
                }));

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

} catch (Exception e) {
                System.out.println("Error occurred: " + e.getMessage());
            }

}));
    }
}
```

当你运行这个程序时，你会发现两个窗口分别显示"Resource 1"和"Resource 2"。这两个线程会等待对方释放资源，从而引发死锁现象。