Java并发编程问题：死锁示例

原创痛定思痛。 2024-09-27 14:54 7阅读 0赞

死锁是并发编程中的一个经典问题，它发生在两个或更多的进程在执行过程中，因争夺资源而造成的一种互相等待的现象，若无外力干涉，它们都将无法继续执行。

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

```java
// 假设我们有4个线程和5个资源

class Resource {
    boolean isAvailable = true;

public synchronized void acquire() {
        if (isAvailable) {
            isAvailable = false;
            notifyAll(); // 通知其他等待的线程
        } else {
            throw new RuntimeException("Resource already acquired by another thread");
        }
    }

public synchronized void release() {
        if (!isAvailable) {
            throw new RuntimeException("Resource not acquired by the current thread");
        }

isAvailable = true;
        notifyAll(); // 通知其他等待的线程
    }
}

class ThreadA extends Thread {
    Resource resourceA;

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

@Override
    public void run() {
        resourceA.acquire(); // 线程A获取资源A

try {
            System.out.println("Thread A is running and using resource A");

// 线程B等待资源A
            Thread.sleep(500);
            ThreadB threadB = new ThreadB(resourceA); // 创建线程B并传递资源A
            threadB.start(); // 启动线程B

// 这里是死锁的点，线程B等待资源A，而资源A被线程A占用
            System.out.println("Thread A is holding resource A and not releasing it");

throw new InterruptedException("Deadlock detected"); // 调用异常，结束当前线程运行
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if (resourceA != null) {
                resourceA.release(); // 线程A释放资源A
            }
        }
    }
}

class ThreadB extends Thread {
    Resource resourceA;

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

@Override
    public void run() {
        try {
            System.out.println("Thread B is waiting for resource A");

// 这里是死锁的点，线程B等待资源A，而资源A被线程A占用
            Thread.sleep(500);
            System.out.println("Thread B acquired resource A after a delay");

} catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

public class Main {
    public static void main(String[] args) {
        Resource resourceA = new Resource(); // 创建资源A
        Resource resourceB = new Resource(); // 创建资源B

ThreadA threadA = new ThreadA(resourceA); // 创建线程A并传递资源A
        ThreadB threadB = new ThreadB(resourceB); // 创建线程B并传递资源B

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

// 这里可能会导致死锁，因为两个线程都在等待对方释放资源
        // 例如，线程A获取了资源A，并且在等待资源B
        // 与此同时，线程B获取了资源B，并且在等待资源A
    }
}
```
这段代码会创建两个线程（Thread A 和 Thread B），每个线程都会尝试获取一个资源（Resource A 和 Resource B）。由于线程A获取了Resource A，然后等待Resource B；而线程B获得了Resource B，然后等待Resource A。这两个线程都进入了“死循环”，导致系统无法继续执行其他任务，从而发生死锁。