Java并发编程：理解和避免死锁问题实例

原创骑猪看日落 2024-09-10 13:06 96阅读 0赞

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

以下是一个简单的例子来理解死锁：

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

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

@Override
    public void run() {
        System.out.println("Thread 1 started");
        
        // 线程等待资源B，而线程1拥有资源B
        while (!b.isAvailable()) {
            try {
                Thread.sleep(100); // 模拟线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

System.out.println("Thread 1 acquired resource B");

// 线程继续等待资源A，而线程1拥有资源A
        while (!a.isAvailable()) {
            try {
                Thread.sleep(200); // 模拟线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

System.out.println("Thread 1 acquired resource A");

// 此时，两个线程都拥有了所有的资源，死锁发生
    }
}

// 线程2拥有资源B和C
public class Thread2 extends Thread {
    private ResourceB b;
    private ResourceC c;

public Thread2(ResourceB b, ResourceC c) {
        this.b = b;
        this.c = c;
    }

@Override
    public void run() {
        System.out.println("Thread 2 started");

// 线程等待资源A，而线程2拥有资源A
        while (!b.isAvailable()) {
            try {
                Thread.sleep(300); // 模拟线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

System.out.println("Thread 2 acquired resource A");

// 线程继续等待资源C，而线程2拥有资源C
        while (!c.isAvailable()) {
            try {
                Thread.sleep(400); // 模拟线程等待
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

System.out.println("Thread 2 acquired resource C");

// 此时，两个线程都拥有了所有的资源，死锁发生
    }
}
```

在上述例子中，线程1持有资源A和B，线程2持有资源B和C。它们互相等待对方释放资源。

当线程1获取到资源B后，它继续等待资源A，而此时线程2已经拥有资源A。这就形成了一个死锁：两个线程都因对方占有资源而无法继续执行。