Java并发编程：死锁案例分析

原创谁借莪１个温暖的怀抱￠ 2024-09-10 21:48 26阅读 0赞

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

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

```java
// 定义两个线程和资源
class Resource {
    private Thread owner;

Resource(Thread owner) {
        this.owner = owner;
    }

// 设计获取资源的方法
    synchronized void acquire() {
        if (owner == null) {  // 如果没有拥有者，那么就设置为当前线程
            owner = Thread.currentThread();
        }
        // 此处添加其他逻辑，例如模拟两个线程争抢资源
        System.out.println("Thread " + Thread.currentThread().getName() + " acquires resource.");
    }

// 设计释放资源的方法
    synchronized void release() {
        if (owner == Thread.currentThread()) {  // 如果当前线程是资源的拥有者
            owner = null;  // 设置资源的拥有者为null，表示资源已释放
            System.out.println("Thread " + Thread.currentThread().getName() + " releases resource.");
        } else {  // 如果当前线程不是资源的拥有者，那么抛出异常
            throw new RuntimeException("Resource is owned by another thread, can't release.");
        }
    }
}

// 定义两个线程，每个都需要一个资源来执行任务
class WorkerThread implements Runnable {
    private Resource resource;

WorkerThread(Resource resource) {
        this.resource = resource;
    }

@Override
    public void run() {
        try {
            // 优先获取资源
            resource.acquire();
            System.out.println("Worker thread " + Thread.currentThread().getName() + " starts processing.");
            // 执行任务
            Thread.sleep(2000);  // 假设需要处理一段时间的任务
            // 释放资源
            resource.release();
            System.out.println("Worker thread " + Thread.currentThread().getName() + " finishes processing.");
        } catch (InterruptedException | RuntimeException e) {
            e.printStackTrace();
            System.out.println("Thread " + Thread.currentThread().getName() + " interrupted or threw an exception.");
        }
    }
}

public class DeadLockExample {
    public static void main(String[] args) {
        // 创建两个资源
        Resource resource1 = new Resource(Thread.currentThread()));
        Resource resource2 = new Resource(Thread.currentThread()));

// 创建两个线程，每个都需要一个资源来执行任务
        Thread workerThread1 = new Thread(new WorkerThread(resource1))));
        Thread workerThread2 = new Thread(new WorkerThread(resource2))));

// 启动线程
        workerThread1.start();
        workerThread2.start();

// 这里是死锁的典型场景，因为两个线程都需要对方先释放资源
        // 通常情况下，这里应该在每个线程开始执行任务之前就设置好资源的拥有者
        // 或者使用更高级的并发工具，如java.util.concurrent.locks库中的Lock接口等
    }
}
```

在这个例子中，`WorkerThread`需要`Resource`来执行任务。两个`WorkerThread`同时运行，但每个都需要对方先释放资源。这就导致了死锁的发生。

要避免这种情况，通常的做法是设置一个优先级或顺序，使得某个线程在获取资源之前必须已经拥有足够的资源。或者使用锁（如Java的Lock接口）机制来控制对共享资源的访问。