Java并发编程：理解和避免死锁问题实例-蒲公英云

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

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

在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");
        // 此时，两个线程都拥有了所有的资源，死锁发生
    }
}