Java并发编程中的死锁问题及解决方案实例演示

原创短命女 2024-11-27 00:00 181阅读 0赞

死锁是Java并发编程中的一种常见问题，它发生在两个或更多的线程互相等待对方释放资源时。

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

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

// 锁住资源
    public void lock() {
        if (!locked) {
            locked = true;
        } else {
            throw new IllegalStateException("Resource is already locked");
        }
    }

// 解锁资源
    public void unlock() {
        if (locked) {
            locked = false;
        } else {
            throw new IllegalStateException("Resource is not locked");
        }
    }
}

// 两个线程，都想要获取对方的资源
class DeadLockExample {
    private Resource resource1, resource2;

// 创建资源
    public void createResources() {
        resource1 = new Resource();
        resource2 = new Resource();
    }

// 死锁示例：线程1和线程2互相等待对方释放资源
    public void deadlockExample() throws InterruptedException {
        createResources();

Thread thread1 = new Thread(() -> acquireResource(resource1)));
        Thread thread2 = new Thread(() -> acquireResource(resource2)));

thread1.start();
        thread2.start();

// 线程会等待对方释放资源
        thread1.join();
        thread2.join();

if (resource1.locked && resource2.locked) {
            System.out.println("A deadlock occurred between the two threads.");
        } else {
            System.out.println("No deadlock occurred between the two threads.");
        }
    }

// 一个线程尝试获取资源
    private void acquireResource(Resource resource) {
        try {
            if (resource.locked) {
                throw new IllegalStateException("Resource is already locked by another thread");
            }

resource.lock();
            System.out.println("Thread " + Thread.currentThread().getName() + " successfully acquired resource " + resource);
        } catch (Exception e) {
            System.out.println("Thread " + Thread.currentThread().getName() + " failed to acquire resource due to error: " + e.getMessage());
        } finally {
            if (resource.locked) {
                resource.unlock();
                System.out.println("Resource was unlocked by another thread.");
            } else {
                resource.unlock();
                System.out.println("Resource was unlocked by the current thread.");
            }
        }
    }
}
```

在这个例子中，线程1（资源1的所有者）和线程2（资源2的所有者）都在等待对方释放资源。这就形成了一个死锁。

解决方案通常是预防性的，即在设计并发程序时，避免出现互斥条件，或者通过超时机制来检测并解除死锁。