解决Java多线程同步中的死锁问题实例

原创红太狼 2024-09-23 07:36 57阅读 0赞

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

以下是一个简单的Java多线程死锁问题的例子：

```java
// 创建两个需要共享资源的类
class Resource {
    private int count = 1;
    // 只允许增加资源数量
    public synchronized void increaseCount() {
        count++;
    }
    // 返回当前资源数量
    public synchronized int getCount() {
        return count;
    }
}

public class DeadLockExample {
    // 创建两个线程，每个线程都需要一个共享的资源
    private Resource resource1, resource2;

public DeadLockExample(Resource resource1, Resource resource2) {
        this.resource1 = resource1;
        this.resource2 = resource2;
    }

// 线程1获取资源1并增加资源数量，等待线程2释放资源2
    public void thread1() {
        resource1.increaseCount();
        System.out.println("Thread 1 acquired resource 1 and increased its count. Waiting for resource 2 to be released.");
        try {
            // 线程挂起，等待资源2被释放
            resource2.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread 1 has finished waiting for resource 2 to be released.");
    }

// 线程2获取资源2并增加资源数量，等待线程1释放资源1
    public void thread2() {
        resource2.increaseCount();
        System.out.println("Thread 2 acquired resource 2 and increased its count. Waiting for resource 1 to be released.");
        try {
            // 线程挂起，等待资源1被释放
            resource1.wait();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Thread 2 has finished waiting for resource 1 to be released.");
    }

public static void main(String[] args) {
        Resource resource1 = new Resource();
        Resource resource2 = new Resource();

DeadLockExample deadLockExample = new DeadLockExample(resource1, resource2);

Thread thread1 = new Thread(deadLockExample::thread1));
        Thread thread2 = new Thread(deadLockExample::thread2));

// 启动线程
        thread1.start();
        thread2.start();

// 等待所有线程执行完毕
        try {
            thread1.join();
            thread2.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，线程1和线程2分别获取并增加两个共享资源的数量。但是，它们的执行顺序是固定的（线程1先获取资源），这导致了死锁的发生：线程2等待资源1释放，线程1等待资源2释放，形成了相互等待对方释放资源的状态。