实例展示Java并发编程中的死锁问题及预防策略

原创旧城等待， 2024-09-30 00:33 64阅读 0赞

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

以下是一个简单的Java并发编程示例，其中可能会产生死锁：

```java
// 线程1持有资源A，需要资源B
class Thread1 implements Runnable {
    private Resource A;
    private Resource B;

public Thread1(Resource A, Resource B) {
        this.A = A;
        this.B = B;
    }

@Override
    public void run() {
        // 线程1获取资源A
        A.use();
        
        // 线程1等待资源B
        while (B.getRequired()) {
            try {
                Thread.sleep(100); // 模拟等待时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 线程1释放资源A
        A.release();

System.out.println("Thread 1 completed.");
    }
}

// 线程2持有资源B，需要资源A
class Thread2 implements Runnable {
    private Resource B;
    private Resource A;

public Thread2(Resource B, Resource A) {
        this.B = B;
        this.A = A;
    }

@Override
    public void run() {
        // 线程2获取资源B
        B.use();

// 线程2等待资源A
        while (A.getRequired()) {
            try {
                Thread.sleep(100); // 模拟等待时间
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

// 线程2释放资源B
        B.release();

System.out.println("Thread 2 completed.");
    }
}

public class Main {
    public static void main(String[] args) {
        Resource A = new Resource("A"));
        Resource B = new Resource("B");

Thread1 t1 = new Thread1(A, B));
        Thread2 t2 = new Thread2(B, A));

t1.start();
        t2.start();

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

System.out.println("All threads completed.");
    }
}
```

在这个例子中，线程1持有资源A，需要资源B。同时，线程2持有资源B，需要资源A。

当线程1和线程2各自完成自己的操作后，它们都会等待对方释放资源，这就可能导致死锁的出现。