Java多线程并发问题：DeadLock案例

原创 Love The Way You Lie 2024-09-13 08:21 69阅读 0赞

在Java多线程编程中， DeadLock 是一种常见的并发问题。当两个或更多的线程相互等待对方释放资源，但这些线程又没有外在因素促使它们继续执行，就会形成死锁。

下面是一个简单的 DeadLock 案例：

```java
// 创建两个互斥的资源
class Resource {
    private boolean locked;

public Resource() {
        locked = false;
    }

// 锁定资源（互斥）
    public synchronized void lock() {
        if (!locked) {
            locked = true;
            notifyAll(); // 唤醒等待锁的线程
        }
    }

// 解除锁定（释放资源）
    public synchronized void unlock() {
        if (locked) {
            locked = false;
            notifyAll(); // 唤醒等待解锁的线程
        }
    }
}

// 创建两个需要互斥的线程
class ThreadA extends Thread {
    private Resource resourceA;

public ThreadA(Resource resourceA) {
        this.resourceA = resourceA;
    }

@Override
    public void run() {
        while (true) { // 无限循环，确保资源被锁定
            try {
                if (!resourceA.lock()) { // 如果线程无法获取锁，退出循环
                    System.out.println("Thread A unable to lock Resource A");
                    break;
                }

// 线程执行一些耗时的操作

resourceA.unlock(); // 解除锁定后，通知其他等待解锁的线程继续执行

} catch (Exception e) {
                System.out.println("Thread A encountered an error: " + e.getMessage());
            }
        }
    }
}

class ThreadB extends Thread {
    private Resource resourceB;

public ThreadB(Resource resourceB) {
        this.resourceB = resourceB;
    }

@Override
    public void run() {
        while (true) { // 无限循环，确保资源被锁定
            try {
                if (!resourceB.lock()) { // 如果线程无法获取锁，退出循环
                    System.out.println("Thread B unable to lock Resource B");
                    break;
                }

// 线程执行一些耗时的操作

resourceB.unlock(); // 解除锁定后，通知其他等待解锁的线程继续执行

} catch (Exception e) {
                System.out.println("Thread B encountered an error: " + e.getMessage());
            }
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Resource resourceA = new Resource();
        ThreadA threadA = new ThreadA(resourceA);
        threadA.start();

Resource resourceB = new Resource();
        ThreadB threadB = new ThreadB(resourceB);
        threadB.start();

// 这里留空，确保两个线程在资源锁定的状态下运行足够长的时间（例如：10秒）。
    }
}
```

这个例子中，ThreadA 和 ThreadB 都需要互斥的 `Resource` 来执行操作。如果一个线程无法获取锁，它将退出循环并打印错误信息。这就会导致死锁，因为两个线程都将等待对方释放资源，从而无法继续执行。