Java多线程：死锁案例解析

原创爱被打了一巴掌 2024-09-10 16:30 23阅读 0赞

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

下面是一个简单的死锁案例，使用Java实现：

```java
// 创建两个线程，它们需要共享的资源
class ThreadA extends Thread {
    private Object lock = new Object();

@Override
    public void run() {
        while (true) {
            synchronized (lock) {
                // 线程A先获取锁
                if (Thread.currentThread().getName() == "ThreadA") {
                    System.out.println("Thread A acquired lock");
                    break; // 获得锁后退出循环
                } else {
                    System.out.println("Thread B waiting for lock");
                    // 线程B等待锁，挂起当前线程
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

class ThreadB extends Thread {
    private Object lock = new Object();

@Override
    public void run() {
        while (true) {
            synchronized (lock) {
                // 线程B先获取锁
                if (Thread.currentThread().getName() == "ThreadB") {
                    System.out.println("Thread B acquired lock");
                    break; // 获得锁后退出循环
                } else {
                    System.out.println("Thread A waiting for lock");
                    // 线程A等待锁，挂起当前线程
                    try {
                        lock.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

// 创建两个线程
ThreadA threadA = new ThreadA();
ThreadB threadB = new ThreadB();

// 启动线程
threadA.start();
threadB.start();
```

在这个例子中，线程A和线程B都需要共享的资源（这里假设是`lock`对象）才能执行。如果它们按照某种顺序获取并释放锁，就可能导致死锁。

要避免死锁，通常会遵循一些原则，如银行家算法等。在上述Java代码中，线程可能会因为等待锁而一直运行，这并不是一个死锁案例，而是资源饥饿的情况。