Java多线程编程中的死锁问题示例

原创迈不过友情╰ 2024-10-21 16:00 35阅读 0赞

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

以下是一个简单的Java死锁示例：

```java
// 创建两个共享资源的类
class Resource {
    private int count = 1;
    
    public synchronized void acquire() {
        if (count == 0) { // 防止空资源的情况
            throw new IllegalStateException("Resource is exhausted");
        }
        count--;
    }
    
    public synchronized void release() {
        count++;
    }
}

// 创建两个线程，一个尝试获取资源，另一个尝试释放资源
class ThreadA extends Thread {
    Resource resource;

public ThreadA(Resource resource) {
        this.resource = resource;
    }

@Override
    public void run() {
        try {
            resource.acquire(); // 线程A尝试获取资源
            System.out.println("Thread A acquired the resource");
        } catch (Exception e) {
            System.out.println("Thread A encountered an error: " + e.getMessage());
        } finally {
            try {
                resource.release(); // 线程B尝试释放资源
                System.out.println("Thread B released the resource");
            } catch (Exception e) {
                System.out.println("Thread B encountered an error: " + e.getMessage());
            }
        }
    }
}

// 创建两个线程，一个尝试获取资源，另一个尝试释放资源
class ThreadB extends Thread {
    Resource resource;

public ThreadB(Resource resource) {
        this.resource = resource;
    }

@Override
    public void run() {
        try {
            resource.release(); // 线程B尝试释放资源
            System.out.println("Thread B released the resource");
        } catch (Exception e) {
            System.out.println("Thread B encountered an error: " + e.getMessage());
        }
        finally {
            try {
                resource.acquire(); // 如果线程A在这里等待，就会发生死锁
                System.out.println("Thread B detected a deadlock situation");
            } catch (Exception e) {
                System.out.println("Thread B encountered an error during deadlock detection: " + e.getMessage());
            }
        }
    }
}

// 创建两个资源，并启动两个尝试获取和释放资源的线程
public class Main {
    public static void main(String[] args) {
        Resource resource1 = new Resource();
        Resource resource2 = new Resource();

ThreadA threadA1 = new ThreadA(resource1);
        ThreadA threadA2 = new ThreadA(resource2);

ThreadB threadB1 = new ThreadB(resource1);
        ThreadB threadB2 = new ThreadB(resource2);

// 启动所有线程
        threadA1.start();
        threadA2.start();
        threadB1.start();
        threadB2.start();
    }
}
```

在这个示例中，如果线程B先释放资源（resource1），然后线程A尝试获取这个资源，就会因为资源已经被其他线程占用而无法获取。这就形成了一个典型的死锁情况。