Java并发问题：死锁实例解读

原创灰太狼 2024-11-28 15:09 36阅读 0赞

在Java编程中，死锁是一个常见的并发问题。死锁发生时，两个或多个线程互相等待对方释放资源，导致它们都无法继续执行。

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

```java
// 定义两个互斥的资源
class Resource1 {
    boolean locked = false;

void lock() { locked = true; }
    void unlock() { locked = false; }
}

class Resource2 {
    boolean locked = false;

void lock() { locked = true; }
    void unlock() { locked = false; }
}
```

现在我们创建两个线程，尝试获取并锁定资源：

```java
public class DeadLockExample {

private Resource1 resource1;
    private Resource2 resource2;

public DeadLockExample() {
        resource1 = new Resource1();
        resource2 = new Resource2();
    }

public void acquireResources(Thread thread) {
        if (thread == Thread.currentThread()) {
            System.out.println("Thread " + thread.getId() + " is acquiring Resource 1.");
            resource1.lock();
            System.out.println("Thread " + thread.getId() + " acquired Resource 1 successfully.");

// Acquire Resource 2
            System.out.println("Thread " + thread.getId() + " is acquiring Resource 2.");
            resource2.lock();
            System.out.println("Thread " + thread.getId() + " acquired Resource 2 successfully.");

} else {
            System.out.println("Thread " + thread.getId() + " cannot acquire resources directly. Requesting other thread to acquire on behalf.");
            thread.requestResources(resource1, resource2), this);
        }
    }

public void runThreads() throws InterruptedException {
        Thread thread1 = new Thread(this, "Thread 1"));
        Thread thread2 = new Thread(this, "Thread 2"));

// Start threads
        thread1.start();
        thread2.start();

// Wait for all threads to finish
        thread1.join();
        thread2.join();
    }

public static void main(String[] args) throws InterruptedException {
        DeadLockExample example = new DeadLockExample();
        example.runThreads();
    }
}
```

在这个例子中，两个线程 `Thread 1` 和 `Thread 2` 分别尝试获取资源 `Resource 1` 和 `Resource 2`。这两个资源是互斥的，即一个资源被锁定时，其他资源都无法被锁定。

因此，当线程 1 请求资源 1 并成功获得锁后，它会进一步请求资源 2。但由于资源 2 正在被线程 2 锁定，所以线程 1 永远无法获得资源 2 的锁，从而导致了死锁。

要避免这种问题，可以采取一些策略来管理资源的获取和释放，例如使用信号量、条件变量等机制来控制并发访问。