Java练习（并发模式）

设计一个简单的生产者-消费者模型，其中生产者负责生成数据，消费者负责处理数据。为了在生产者和消费者之间传递数据，使用一个有界缓冲区（例如，`ArrayBlockingQueue`）作为它们之间的通信通道。

要求：

1. 创建一个`Producer`类，该类包含一个`produce()`方法，用于生成数据。生成的数据应该是一个整数，范围在1到100之间。
2. 创建一个`Consumer`类，该类包含一个`consume()`方法，用于处理数据。处理数据的方式是将接收到的整数打印到控制台。
3. 在`main`方法中，创建一个`ArrayBlockingQueue`实例作为缓冲区，以及一个`Producer`和一个`Consumer`实例。然后，创建两个线程，一个用于执行生产者的`produce()`方法，另一个用于执行消费者的`consume()`方法。
4. 生产者应该不断地生成数据并将其放入缓冲区，直到缓冲区满为止。当缓冲区满时，生产者应该等待消费者处理数据并释放空间。
5. 消费者应该不断地从缓冲区中取出数据并处理，直到缓冲区为空为止。当缓冲区为空时，消费者应该等待生产者生成数据。
 

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

// 定义Producer类
class Producer {
    private final BlockingQueue<Integer> queue;

    public Producer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    public void produce() {
        try {
            int data = (int) (Math.random() * 100) + 1;
            queue.put(data);
            System.out.println("生产者生成数据: " + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 定义Consumer类
class Consumer {
    private final BlockingQueue<Integer> queue;

    public Consumer(BlockingQueue<Integer> queue) {
        this.queue = queue;
    }

    public void consume() {
        try {
            int data = queue.take();
            System.out.println("消费者处理数据: " + data);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

// 主类
public class Main {
    public static void main(String[] args) {
        // 创建一个有界缓冲区
        BlockingQueue<Integer> queue = new ArrayBlockingQueue<>(10);

        // 创建生产者和消费者实例
        Producer producer = new Producer(queue);
        Consumer consumer = new Consumer(queue);

        // 创建线程执行生产者和消费者的方法
        Thread producerThread = new Thread(() -> {
            while (true) {
                producer.produce();
                if (queue.size() >= queue.remainingCapacity()) {
                    break;
                }
            }
        });

        Thread consumerThread = new Thread(() -> {
            while (true) {
                consumer.consume();
                if (queue.isEmpty()) {
                    break;
                }
            }
        });

        // 启动线程
        producerThread.start();
        consumerThread.start();
    }
}