实战演练：Java多线程同步问题：死锁案例

原创超、凢脫俗 2024-09-23 16:57 74阅读 0赞

在Java编程中，多线程同步是非常重要的部分，尤其是处理共享资源的场景。如果操作不当，就可能产生死锁现象。

以下是一个经典的Java多线程死锁案例：

```java
// 假设我们有四个共享资源：
public class Resource {
    private int count;

// 构造器
    public Resource() {
        count = 0;
    }

// 获取当前计数
    public int getCount() {
        return count;
    }

// 增加计数
    public void incrementCount() {
        count++;
    }
}

// 线程类，每个线程请求两个资源
public class ThreadA extends Thread {
    private Resource resource1, resource2;

// 构造器
    public ThreadA(Resource resource1, Resource resource2) {
        this.resource1 = resource1;
        this.resource2 = resource2;
    }

@Override
    public void run() {
        while (true) { // 无限循环，模拟资源请求
            if (resource1.getCount() < 2) {
                resource1.incrementCount();
                System.out.println("Thread A: Request Resource 1 " + resource1.getCount());
                try {
                    // 模拟其他线程等待
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } else if (resource2.getCount() < 2) {
                resource2.incrementCount();
                System.out.println("Thread A: Request Resource 2 " + resource2.getCount());
                try {
                    // 模拟其他线程等待
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

// 主程序，启动两个请求资源的线程
public class Main {
    public static void main(String[] args) {
        Resource resource1 = new Resource();
        Resource resource2 = new Resource();

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

threadA1.start(); // 启动线程A1
        threadA2.start(); // 启动线程A2

try {
            // 模拟主线程等待，直到两个线程都完成
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

这个案例中，两个线程`ThreadA1`和`ThreadA2`分别请求资源1和资源2。由于资源的限制，每个资源只能被一个线程占用。

当`ThreadA1`请求资源1并增加计数时，如果`ThreadA2`也正在请求资源1，那么`ThreadA2`将会等待，直到`ThreadA1`释放资源。

这样的情况下就形成了死锁：两个或更多的线程在执行过程中因争夺资源而造成的一种互相等待的现象，若无外力作用它们都将无法继续执行。