Java并发编程中死锁的产生及解决：案例演示

原创怼烎@ 2024-11-26 01:36 35阅读 0赞

死锁是Java并发编程中的一个常见问题。它发生在两个或更多的线程相互等待对方释放资源的情况下，系统无法进行任何操作。

下面是一个简单的死锁产生案例：

```java
// 线程1拥有资源A
class Thread1 extends Thread {
    private Object resourceA;

public Thread1(Object resourceA) {
        this.resourceA = resourceA;
    }

@Override
    public void run() {
        while (true) { // 无限循环，等待线程2释放资源B
            synchronized (resourceA) { // 尝试获取资源A
                if (!Thread.currentThread().equals(Thread2))) { // 如果不是线程2，那么尝试获取资源B
                    synchronized (resourceB) {
                        resourceB = null; // 线程2释放资源B
                        break; // 走出同步块，获取到资源B
                    }
                } else { // 如果是线程2，那么直接等待资源B被释放
                    try {
                        synchronized (resourceB) {
                            while (Thread.currentThread().equals(Thread2))) { // 等待线程2释放资源B
                                // 在这里添加你的阻塞操作
                                // ...
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

public Object getResourceB() {
        return resourceB;
    }
}

// 线程2拥有资源B
class Thread2 extends Thread {
    private Object resourceB;

public Thread2(Object resourceB) {
        this.resourceB = resourceB;
    }

@Override
    public void run() {
        while (true) { // 无限循环，等待线程1释放资源A
            synchronized (resourceB) { // 尝试获取资源B
                if (!Thread.currentThread().equals(Thread1))) { // 如果不是线程1，那么尝试获取资源A
                    synchronized (resourceA) {
                        resourceA = null; // 线程1释放资源A
                        break; // 走出同步块，获取到资源A
                    }
                } else { // 如果是线程1，那么直接等待资源A被释放
                    try {
                        synchronized (resourceA) {
                            while (Thread.currentThread().equals(Thread1))) { // 等待线程1释放资源A
                                // 在这里添加你的阻塞操作
                                // ...
                            }
                        }
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
    }

public Object getResourceA() {
        return resourceA;
    }
}
```

在这个案例中，线程1拥有资源A，线程2拥有资源B。两个线程互相等待对方释放资源。这种情况下，如果两个线程按照这种方式无限循环，就可能导致死锁。

解决死锁的方法通常包括避免循环等待、设置超时机制以及使用死锁预防或检测算法等。