Java多线程编程：常见的死锁问题实例

原创秒速五厘米 2024-11-25 18:42 6阅读 0赞

死锁是多线程编程中一个关键的问题。当两个或更多的线程互相等待对方释放资源，但又没有外力能打破这种状态时，就产生了死锁。

下面提供一个简单的Java死锁实例：

```java
// 定义两个互斥的资源
class Resource {
    private boolean locked = false;

// 锁定资源
    public synchronized void lock() {
        if (locked) {
            throw new IllegalStateException("Resource is already locked");
        }
        locked = true;
        notifyAll(); // 唤醒所有等待锁资源的线程
    }

// 解锁资源
    public synchronized void unlock() {
        if (!locked) {
            throw new IllegalStateException("Resource is not locked");
        }
        locked = false;
        notifyAll(); // 唤醒所有等待锁资源释放的线程
    }
}

// 定义两个线程，分别尝试获取两个互斥的资源
class ThreadA extends Thread {
    private Resource resourceA;

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

@Override
    public void run() {
        try {
            // 获取资源A
            resourceA.lock();
            System.out.println("Thread A acquired resource A");

// 等待资源B
            Resource resourceB = new Resource(); // 创建一个新资源B
            resourceB.lock();
            System.out.println("Thread A acquired resource B");

// 执行一些操作后释放资源
            Thread.sleep(2000); // 模拟执行一段时间的操作

// 释放资源B
            resourceB.unlock();

// 释放资源A，确保资源B已被释放
            resourceA.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class ThreadB extends Thread {
    private Resource resourceB;

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

@Override
    public void run() {
        try {
            // 获取资源B
            resourceB.lock();
            System.out.println("Thread B acquired resource B");

// 等待资源A
            Resource resourceA = new Resource(); // 创建一个新资源A
            resourceA.lock();
            System.out.println("Thread B acquired resource A");

// 执行一些操作后释放资源
            Thread.sleep(2000); // 模拟执行一段时间的操作

// 释放资源A，确保资源B已被释放
            resourceA.unlock();

// 释放资源B，完成死锁的解除
            resourceB.unlock();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 主函数，创建线程并启动它们
public static void main(String[] args) {
    Resource resourceA = new Resource(); // 创建资源A
    Resource resourceB = new Resource(); // 创建资源B

ThreadA threadA = new ThreadA(resourceA); // 创建线程A
    ThreadB threadB = new ThreadB(resourceB); // 创建线程B

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

这个例子中，两个线程（ThreadA和ThreadB）分别尝试获取两个互斥的资源（ResourceA和ResourceB）。结果是它们会形成一个死锁循环：线程A获取ResourceA后等待ResourceB，而线程B在获取ResourceB后等待ResourceA。这种情况下，没有外部力量能打破这个状态，因此形成了死锁。