Java多线程并发中，死锁的示例

原创港控/mmm° 2024-09-26 07:00 71阅读 0赞

死锁是多线程并发编程中的一个严重问题。当两个或更多的线程相互等待对方释放资源时，就会出现死锁。

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

```java
// 线程A和B分别拥有资源1和2
class ThreadA extends Thread {
    Resource1 resource1;

ThreadA(Resource1 res) {
        resource1 = res;
    }

@Override
    public void run() {
        try {
            acquireResource1();
            // 线程B等待线程A释放资源2
            acquireResource2();
            System.out.println("Thread A completed");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private void acquireResource1() throws InterruptedException {
        resource1.lock();
        // 确保线程B不会立即获取资源2
        Thread.sleep(100);
        resource1.unlock();
    }

private Resource2 resource2;

private void acquireResource2() throws InterruptedException {
        resource2 = new Resource2();
        resource2.lock();
        // 等待线程A释放资源1，以便我们可以立即获取它
        resource1.unlock();
        resource2.unlock();
    }
}

class ThreadB extends Thread {
    Resource2 resource2;

ThreadB(Resource2 res) {
        resource2 = res;
    }

@Override
    public void run() {
        try {
            acquireResource2();
            // 等待线程A释放资源1，以便我们可以立即获取它
            acquireResource1();
            System.out.println("Thread B completed");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

private void acquireResource1() throws InterruptedException {
        resource1.lock();
        // 确保线程B不会立即获取资源2，以便我们可以立即释放它
        Thread.sleep(100);
        resource1.unlock();
    }

private Resource2 resource2;

private void acquireResource2() throws InterruptedException {
        resource2 = new Resource2();
        resource2.lock();
        // 等待线程B释放资源1，以便我们可以立即获取它
        resource1.unlock();
        resource2.unlock();
    }
}

public class Main {
    public static void main(String[] args) {
        ThreadA threadA = new ThreadA(Resource1.getInstance()));
        ThreadB threadB = new ThreadB(Resource2.getInstance()));

threadA.start();
        threadB.start();

try {
            threadA.join();
            threadB.join();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}
```

在这个例子中，线程A持有资源1，并等待线程B释放资源2。同时，线程B持有资源2，并等待线程A释放资源1。

当两个线程都等待对方释放资源时，就形成了死锁。