理解Java多线程中的死锁问题实例

原创女爷i 2024-12-07 12:45 13阅读 0赞

死锁在Java多线程中是一个常见的并发问题。当两个或更多的线程互相等待对方释放资源时，就会发生死锁。

下面是一个简单的例子，说明如何在Java中创建并引发死锁：

```java
// 线程1拥有资源A
public class Thread1 extends Thread {
    private ResourceA a;

public Thread1(ResourceA a) {
        this.a = a;
    }

@Override
    public void run() {
        try {
            // 先获取资源A，然后去获取资源B
            a.use();
            ResourceB b = new ResourceB(a);
            b.use();  // 这里会等待b的使用，但是a无法释放

// 死锁状态：线程1等待Thread2释放资源B；线程2等待Thread1释放资源A
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

public static class ResourceA {
        private boolean isUsed;

public ResourceA() {
            isUsed = false;
        }

public void use() throws InterruptedException {
            if (!isUsed) {
                synchronized (this) {
                    isUsed = true;
                    notifyAll();  // 唤醒所有等待资源的线程
                }
            } else {
                wait();  // 如果资源已经被使用，那么当前线程需要等待
            }
        }
    }

public static class ResourceB extends Thread {
        private ResourceA a;

public ResourceB(ResourceA a) {
            this.a = a;
        }

@Override
        public void run() {
            try {
                // 先获取资源B，然后去获取资源A
                ResourceA temp = a.use();  // 这里会等待temp的使用，但是a无法释放

// 死锁状态：线程2等待Thread1释放资源A；线程1等待Thread2释放资源B
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
    }

public static void main(String[] args) {
        ResourceA a = new ResourceA();
        Thread t1 = new Thread1(a);
        Thread t2 = new Thread2(a);

// 启动线程
        t1.start();
        t2.start();

try {
            // 等待所有线程执行完毕
            t1.join();
            t2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

System.out.println("Deadlock detection successful!");
    }
}
```

在这个例子中，资源A和B被两个线程（Thread1和Thread2）依次占用。因为每个线程都要求对方释放资源后才能继续操作，这就形成了一个死锁状态。

如果在主线程的`join()`方法后面添加必要的逻辑，例如在检测到死锁前先释放已经持有的资源，那么就可以避免这个例子中的死锁问题。