Java并发编程中常见锁问题案例

原创 Dear 丶 2024-11-29 21:36 16阅读 0赞

在Java并发编程中，常见的锁问题包括死锁、活锁、饥饿等问题。下面举几个具体的例子：

1. 死锁：
```java
// 两个线程相互等待资源
class Resource {
    // 需要一个线程来释放这个资源
    synchronized void acquire() {
        if (state != UNAVAILABLE) {
            throw new IllegalStateException("Resource already acquired");
        }
        state = ACQUIRED;
        notifyOne();
    }

// 线程需要释放资源
    synchronized void release() {
        if (state != ACQUIRED) {
            throw new IllegalStateException("Resource not acquired");
        }
        state = UNAVAILABLE;
        notifyAll();
    }

private int state = UNAVAILABLE;
}
```
在这个例子中，两个线程分别等待一个资源。但是因为没有排序，两个线程可能会同时尝试获取资源，从而导致死锁。

2. 活锁：
```java
// 两个线程互相等待对方释放资源
class Resource {
    private int state = 0;

// 线程需要获取资源
    synchronized void acquire() throws InterruptedException {
        while (state != 1) { // 直到资源被释放
            wait();
        }
        state = 2; // 获取资源后，状态变为已占用
        notifyAll(); // 唤醒可能正在等待的线程
    }

// 线程需要释放资源
    synchronized void release() {
        if (state != 2) { // 若资源已被占用或获取时的状态不为2，则抛出异常
            throw new IllegalStateException("Resource already in use");
        }
        state = 1; // 释放资源，状态变为可获取
        notifyAll(); // 唤醒可能正在等待的线程
    }

public void printState() {
        System.out.println("Resource State: " + state);
    }
}
```
在这个例子中，两个线程交替使用一个`Resource`对象。但是当线程2释放资源后，线程1却因为还在等待资源而无法进入，从而形成了活锁现象。

以上就是Java并发编程中常见的锁问题案例，理解和解决这些问题对于编写高效并发程序至关重要。