Java多线程通信中的死锁问题实例

原创超、凢脫俗 2024-09-21 00:00 8阅读 0赞

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

以下是一个简单的Java多线程死锁例子：

```java
// 线程1需要资源A和资源B
class Thread1 extends Thread {
    private Object resourceA;
    private Object resourceB;

public Thread1(Object resourceA, Object resourceB) {
        this.resourceA = resourceA;
        this.resourceB = resourceB;
    }

@Override
    public void run() {
        try {
            lock(resourceA);
            lock(resourceB);
            System.out.println("Thread 1: Resource acquired successfully");
            // 这里假设资源释放是线程安全的
            release(resourceA);
            release(resourceB);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("Thread 1: Interrupted");
        }
    }

private synchronized void lock(Object resource) throws InterruptedException {
        while (true) {
            if (!ownerOf(resource)) {
                tryLock(resource);
                break;
            }
            wait();
        }
    }

private synchronized boolean ownerOf(Object resource) {
        // 这里假设资源的拥有者是线程安全的
        return resource == resourceA || resource == resourceB;
    }

private void tryLock(Object resource) throws InterruptedException {
        lock(resource);
    }

private synchronized void release(Object resource) {
        if (resource == resourceA) {
            threadThatOwnsResourceA.notify();
        } else if (resource == resourceB) {
            threadThatOwnsResourceB.notify();
        }
    }
}

// 线程2需要资源B和资源C
class Thread2 extends Thread {
    private Object resourceB;
    private Object resourceC;

public Thread2(Object resourceB, Object resourceC) {
        this.resourceB = resourceB;
        this.resourceC = resourceC;
    }

@Override
    public void run() {
        try {
            lock(resourceB);
            lock(resourceC);
            System.out.println("Thread 2: Resource acquired successfully");
            // 这里假设资源释放是线程安全的
            release(resourceB);
            release(resourceC);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            System.out.println("Thread 2: Interrupted");
        }
    }

private synchronized boolean ownerOf(Object resource) {
        // 这里假设资源的拥有者是线程安全的
        return resource == resourceB || resource == resourceC;
    }

private void tryLock(Object resource) throws InterruptedException {
        lock(resource);
    }

private synchronized void release(Object resource) {
        if (resource == resourceB) {
            threadThatOwnsResourceB.notify();
        } else if (resource == resourceC) {
            threadThatOwnsResourceC.notify();
        }
    }
}
```

在这个例子中，线程1需要资源A和资源B，线程2需要资源B和资源C。如果两个线程同时获取各自所需的所有资源，就会发生死锁。