使用Java的并发问题：死锁示例

原创叁歲伎倆 2024-10-07 23:15 31阅读 0赞

在Java的多线程编程中，死锁是一种常见的并发问题。当两个或更多的线程因争夺资源而造成的一种互相等待的现象时，就可能出现死锁。

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

```java
// 定义两个互斥的资源
class Resource1 {
    public void acquire() { // 获取资源
        System.out.println("Thread 1 acquired Resource 1");
    }
}

class Resource2 {
    public void acquire() { // 获取资源
        System.out.println("Thread 2 acquired Resource 2");
    }
}

// 定义两个线程，每个线程需要获取两个资源才能继续执行
class Thread1 extends Thread {
    Resource1 resource1;
    Resource2 resource2;

public Thread1(Resource1 resource1, Resource2 resource2) {
        this.resource1 = resource1;
        this.resource2 = resource2;
    }

@Override
    public void run() {
        try {
            resource1.acquire(); // 获取Resource 1
            resource2.acquire(); // 获取Resource 2

System.out.println("Thread 1 finished execution");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

class Thread2 extends Thread {
    Resource1 resource1;
    Resource2 resource2;

public Thread2(Resource1 resource1, Resource2 resource2) {
        this.resource1 = resource1;
        this.resource2 = resource2;
    }

@Override
    public void run() {
        try {
            resource2.acquire(); // 获取Resource 2
            resource1.acquire(); // 获取Resource 1

System.out.println("Thread 2 finished execution");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 创建并启动线程
public class Main {
    public static void main(String[] args) {
        Resource1 resource1 = new Resource1();
        Resource2 resource2 = new Resource2();

Thread1 thread1 = new Thread1(resource1, resource2));
        Thread2 thread2 = new Thread2(resource1, resource2));

thread1.start(); // 启动线程1
        thread2.start(); // 同时启动线程2

try {
            // 等待所有线程执行完毕
            thread1.join();
            thread2.join();

System.out.println("All threads finished execution");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，`Resource1`和`Resource2`是两个互斥的资源。`Thread1`需要先获取`Resource1`，再获取`Resource2`才能继续执行。同样，`Thread2`也需要按照相同的顺序获取资源。

如果线程1在获取`Resource1`时被阻塞，而此时线程2已经开始获取`Resource2`，那么就可能导致死锁。