Java多线程编程中的死锁问题示例

原创女爷i 2024-10-10 22:12 70阅读 0赞

死锁是多线程编程中的一种常见问题。当两个或更多的线程在执行过程中，因争夺资源而造成的一种互相等待的现象称为死锁。

以下是一个简单的Java多线程死锁例子：

```java
// 线程1
public class Thread1 extends Thread {
    private Object lock = new Object();

@Override
    public void run() {
        synchronized (lock) {
            System.out.println("Thread 1: Acquiring lock...");

try {
                // 模拟线程需要的资源
                Thread.sleep(2000); // 假设需要等待2秒

System.out.println("Thread 1: Lock acquired! Using resource...");

} catch (InterruptedException e) {
                System.out.println("Thread 1: Interrupted while acquiring lock. Exiting.");
                e.printStackTrace();
                return;
            } finally {
                // 在finally块中确保释放锁
                System.out.println("Thread 1: Releasing lock...");

synchronized (lock) {
                    lock.notifyAll(); // 唤醒所有等待锁的线程
                    System.out.println("Thread 1: Lock released!");
                }
            }
        }
    }
}

// 线程2
public class Thread2 extends Thread {
    private Object lock = new Object();

@Override
    public void run() {
        synchronized (lock) {
            System.out.println("Thread 2: Acquiring lock...");

try {
                // 模拟线程需要的资源
                Thread.sleep(1000); // 假设需要等待1秒

System.out.println("Thread 2: Lock acquired! Using resource...");

} catch (InterruptedException e) {
                System.out.println("Thread 2: Interrupted while acquiring lock. Exiting.");
                e.printStackTrace();
                return;
            } finally {
                // 在finally块中确保释放锁
                System.out.println("Thread 2: Releasing lock...");

synchronized (lock) {
                    lock.notifyAll(); // 唤醒所有等待锁的线程
                    System.out.println("Thread 2: Lock released!");
                }
            }
        }
    }
}

// 主程序启动两个线程
public class Main {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();

// 启动两个线程
        thread1.start();
        thread2.start();
    }
}
```

在这个例子中，线程1持有锁`lock1`并等待资源。线程2持有锁`lock2`并等待线程1释放锁。

当线程1获取到资源后，它会尝试释放`lock1`以便其他线程可以使用这个锁。但是由于线程2已经持有`lock2`，所以线程1无法释放锁，从而导致死锁。