Java多线程中的DeadLock问题实例

原创谁践踏了优雅 2024-10-22 09:18 26阅读 0赞

DeadLock是Java多线程中的一种常见问题。它发生在两个或多个线程相互等待对方释放资源，从而形成一种“僵持”的状态。

以下是一个简单的DeadLock问题实例：

```java
// 定义两个类，一个需要锁A，另一个需要锁B

public class ResourceA {
    Lock lockA = new ReentrantLock();

public void acquire() {
        lockA.lock();
        System.out.println("Resource A acquired by thread " + Thread.currentThread().getName());
    }

public void release() {
        lockA.unlock();
        System.out.println("Resource A released by thread " + Thread.currentThread().getName());
    }
}

public class ResourceB {
    Lock lockB = new ReentrantLock();

public void acquire() {
        lockB.lock();
        System.out.println("Resource B acquired by thread " + Thread.currentThread().getName());
    }

public void release() {
        lockB.unlock();
        System.out.println("Resource B released by thread " + Thread.currentThread().getName());
    }
}

// 主线程，尝试获取锁A和锁B

public class MainThread extends Thread {
    @Override
    public void run() {
        ResourceA resourceA = new ResourceA();
        ResourceB resourceB = new ResourceB();

// 试图先获取锁A
        resourceA.acquire(); // 这里可能会阻塞，因为资源B尚未释放

// 然后尝试获取锁B
        resourceB.acquire(); // 这里也可能会阻塞，因为资源A尚未释放

// 如果这里没有阻塞，那么就可能产生DeadLock
        // 释放资源，结束循环
        resourceA.release();
        resourceB.release();
    }
}

// 启动主线程
public class Main {
    public static void main(String[] args) {
        MainThread mt = new MainThread();
        mt.start();
    }
}
```

在这个例子中，主线程试图先获取锁A，再获取锁B。然而，如果资源B在获取锁A之前就被释放了，那么后续的线程就会因为无法获得锁A而陷入阻塞状态。这就产生了DeadLock问题。