使用Java实现并发问题案例

原创女爷i 2024-12-03 23:51 30阅读 0赞

在Java中，我们可以遇到多种并发问题。这里我将提供一个常见的生产者消费者问题案例，并用Java进行实现。

**生产者消费者问题简述：**

- 有一个缓冲区（如List）和两个线程：生产者（Producer）和消费者（Consumer）。
- 生产者负责往缓冲区添加元素。
- 消费者负责从缓冲区取出元素并使用它们。

下面是一个简单的Java实现：

```java
import java.util.LinkedList;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

public class ConcurrentProblem {
    private final Lock lock = new ReentrantLock();
    private LinkedList<Integer> buffer = new LinkedList<>();

public void producer(int num) {
        lock.lock();
        try {
            buffer.add(num);
            System.out.println("Producer added: " + num);
            // 如果缓冲区已满，消费者将被唤醒
            if (buffer.size() >= 5) {
                consumer();
            }
        } finally {
            lock.unlock();
        }
    }

public void consumer() {
        lock.lock();
        try {
            if (!buffer.isEmpty()) {
                System.out.println("Consumer consumed: " + buffer.remove(0));
                // 消费者完成任务后，可以唤醒生产者
                if (buffer.size() == 0) {
                    producer(1);
                }
            } else {
                System.out.println("Buffer is empty, no action.");
            }
        } finally {
            lock.unlock();
        }
    }

public static void main(String[] args) {
        ConcurrentProblem problem = new ConcurrentProblem();
        new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                problem.producer(i);
                // 控制生产者速度，使其与消费者匹配
                if (i % 3 == 0) {
                    try {
                        Thread.sleep(500); // 模拟耗时操作
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
            }
        })).start();

// 消费者单独运行，与生产者同步完成任务
        new Thread(() -> {
            while (!problem.buffer.isEmpty())) {
                problem.consumer();
                try {
                    Thread.sleep(100); // 模拟耗时操作
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        })).start();
    }
}
```

这个例子中，生产者负责往缓冲区添加元素（模拟数据），消费者负责从缓冲区取出元素并使用它们。

通过控制生产者和消费者的执行速度，可以模拟出各种并发问题。