Java多线程难题：死锁示例及解决策略

原创淩亂°似流年 2024-10-22 20:24 22阅读 0赞

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

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

```java
// 线程1
class Thread1 extends Thread {
    Object lock1 = new Object();
    Object lock2 = new Object();

public void run() {
        synchronized (lock1) {
            System.out.println("Thread 1 acquired lock1");
            try {
                // 等待锁2
                synchronized (lock2) {
                    System.out.println("Thread 1 acquired lock2");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("Thread 1 released both locks");
                unlock(lock1);
                unlock(lock2);
            }
        }
    }

private void unlock(Object lock) {
        synchronized (lock) {
            System.out.println("Thread 1 unlocked " + lock);
            lock = null;
        }
    }
}

// 线程2
class Thread2 extends Thread {
    Object lock1 = new Object();
    Object lock2 = new Object();

public void run() {
        synchronized (lock1) {
            System.out.println("Thread 2 acquired lock1");
            try {
                // 等待锁2
                synchronized (lock2) {
                    System.out.println("Thread 2 acquired lock2");
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            } finally {
                System.out.println("Thread 2 released both locks");
                unlock(lock1);
                unlock(lock2);
            }
        }
    }

private void unlock(Object lock) {
        synchronized (lock) {
            System.out.println("Thread 2 unlocked " + lock);
            lock = null;
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Thread1 thread1 = new Thread1();
        Thread2 thread2 = new Thread2();

thread1.start();
        thread2.start();
    }
}
```

在这个示例中，线程1需要锁1和锁2来执行其操作。同样，线程2也需要这些锁。

当线程1获取了锁1后，它会等待锁2。然而，如果此时线程2先获得了锁2并等待锁1，那么两个线程就会陷入循环等待中，导致死锁。

解决死锁的策略通常包括：

1. **预防死锁**：设计系统时避免出现可能导致死锁的资源分配和使用顺序。

2. **检测死锁**：在系统运行过程中，通过某种机制监控资源分配情况，当发现可能死锁的情况时，立即中断可能导致死锁的操作。

3. **恢复活线程**：在检测到死锁后，根据系统的实际情况，选择部分线程恢复其执行，以缓解系统状态。