Java多线程实践：死锁问题实例展示

原创落日映苍穹つ 2024-10-08 01:21 71阅读 0赞

死锁在多线程编程中是一个常见的并发问题。当两个或更多的线程互相等待对方释放资源，但这些资源又都在各自的等待中时，就形成了死锁。

下面，我们将通过一个简单的Java代码实例来展示如何避免和解决死锁问题：

```java
// 定义线程类
class ThreadA implements Runnable {
    private Object resource;

ThreadA(Object resource) {
        this.resource = resource;
    }

@Override
    public void run() {
        // 线程A需要资源B，但线程B也需要资源A
        synchronized (resource) {  // 这里用到了synchronized关键字，确保资源的互斥访问
            if (Thread.currentThread().getName() == "ThreadB") {
                System.out.println("ThreadB获取到资源A");
                // 线程B获取到资源A后，释放资源并进入等待状态
                synchronized (resource) {  // 再次同步以确保资源的释放
                    resource.notifyAll();  // 使用notifyAll()方法唤醒所有等待的线程
                    System.out.println("ThreadB释放资源A");
                }
            } else {
                System.out.println("ThreadA获取到资源B");
                // 线程A获取到资源B后，释放资源并进入等待状态
                synchronized (resource) {  // 再次同步以确保资源的释放
                    resource.notifyAll();  // 使用notifyAll()方法唤醒所有等待的线程
                    System.out.println("ThreadA释放资源B");
                }
            }
        } else {
            System.out.println("当前线程无需获取资源，直接进入运行状态。");
        }
    }
}

class ThreadB implements Runnable {
    private Object resource;

ThreadB(Object resource) {
        this.resource = resource;
    }

@Override
    public void run() {
        // 线程B需要资源A，但线程A也需要资源B，两者互不释放
        synchronized (resource) {  // 使用synchronized关键字确保资源的互斥访问
            if (Thread.currentThread().getName() == "ThreadA") {
                System.out.println("ThreadA获取到资源B");
                // 线程A获取到资源B后，释放资源并进入等待状态
                synchronized (resource) {  // 再次同步以确保资源的释放
                    resource.notifyAll();  // 使用notifyAll()方法唤醒所有等待的线程
                    System.out.println("ThreadA释放资源B");
                }
            } else {
                System.out.println("ThreadB获取到资源A");
                // 线程B获取到资源A后，释放资源并进入等待状态
                synchronized (resource) {  // 再次同步以确保资源的释放
                    resource.notifyAll();  // 使用notifyAll()方法唤醒所有等待的线程
                    System.out.println("ThreadB释放资源A");
                }
            }
        } else {
            System.out.println("当前线程无需获取资源，直接进入运行状态。");
        }
    }
}

public class Main {
    public static void main(String[] args) {
        // 创建资源对象并传入两个线程
        Object resource = new Object();
        ThreadA threadA = new ThreadA(resource);
        ThreadB threadB = new ThreadB(resource);

// 启动线程
        threadA.start();
        threadB.start();

// 等待所有线程完成执行
        try {
            threadA.join();
            threadB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，我们创建了两个需要互斥资源的线程——ThreadA和ThreadB。通过synchronized关键字确保了资源的互斥访问。

运行这段代码，你会看到两个线程交替执行获取资源和释放资源的过程，从而避免了死锁的发生。