Java并发编程常见的死锁问题实例

原创迈不过友情╰ 2024-09-21 21:00 94阅读 0赞

死锁是并发编程中一个常见的问题，它发生在两个或更多的进程在执行过程中因争夺资源而造成的一种互相等待的现象。

以下是一个简单的Java并发死锁例子：

```java
// 进程1，需要资源A和B
class Process1 implements Runnable {
    private Object a, b;

public Process1(Object a, Object b) {
        this.a = a;
        this.b = b;
    }

@Override
    public void run() {
        // 先获取资源A
        synchronized (a) {
            System.out.println("Process 1 got A");

// 再去尝试获取资源B
            try {
                synchronized (b) {
                    System.out.println("Process 1 got B");

// 此时，两个进程都成功获取了资源
                    return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

// 如果不能获取资源B，那么等待
            try {
                a.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

// 进程2，需要资源A和B的互斥
class Process2 implements Runnable {
    private Object a, b;

public Process2(Object a, Object b) {
        this.a = a;
        this.b = b;
    }

@Override
    public void run() {
        // 先尝试获取资源B，如果不能，那么等待
        try {
            synchronized (b) {
                System.out.println("Process 2 got B");

// 获取到资源后，立即释放资源A的锁
                synchronized (a) {
                    System.out.println("Process 2 released A");

return;
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

// 如果不能获取资源B，那么等待
            try {
                b.wait();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Object a = new Object();
        Object b = new Object();

Process1 process1 = new Process1(a, b);
        Process2 process2 = new Process2(a, b);

Thread thread1 = new Thread(process1);
        Thread thread2 = new Thread(process2);

thread1.start();
        thread2.start();
    }
}
```

在这个例子中，两个进程（Process 1 和 Process 2）都需要资源A和B。但是，它们的执行顺序是互斥的，即一个进程获取资源B后，另一个进程才能获取资源B。

这就导致了死锁：两个进程都阻塞在等待对方释放资源的过程中。