java设计产品类、生产者类和消费者类，生成相应类的对象，生产者和消费者同时对同一产品（多个）进行生产或消费，利用线程平衡生产和消费的过程。共享缓冲区最多可以放置4个产品，生产者A和生产者B各生产多个产品；消费者1、2、3每次可以取一个产品。输出生产者、消费者的状态。

在Java中，我们可以使用多线程和同步机制来模拟这种生产者-消费者模型。首先，我们创建三个类：Product（产品）、Producer（生产者）和Consumer（消费者）。以下是每个类的基本设计：

1. **Product** 类：
- 构造函数：初始化产品数量
- 布尔变量 `isFull` 和 `isEmpty` 表示缓冲区是否满或空
- 属性：产品列表

public class Product {
    private final int MAX_CAPACITY = 4;
    private List<Product> products = new ArrayList<>();
    private boolean isFull, isEmpty;

    public Product() {
        isFull = isEmpty = false;
    }

    // 添加产品方法
    public synchronized void addProduct(Product product) {
        if (products.size() < MAX_CAPACITY && !isFull) {
            products.add(product);
            isFull = products.size() == MAX_CAPACITY;
            notifyAll(); // 醒通知消费者
        }
    }

    // 消费产品方法
    public synchronized Product consumeProduct() throws InterruptedException {
        while (products.isEmpty() || isFull) {
            wait(); // 等待生产者添加产品
        }
        Product product = products.remove(0);
        isEmpty = products.isEmpty();
        notifyAll(); // 醒通知其他消费者
        return product;
    }
}

2. **Producer** 类：
- 生产产品并放入缓冲区
- 使用 `synchronized` 关键字保证线程安全

public class Producer extends Thread {
    private Product product;
    
    public Producer(String name, Product prod) {
        super(name);
        this.product = prod;
    }

    @Override
    public void run() {
        for (int i = 0; i < 10; i++) { // 生产10个产品
            try {
                product.addProduct(new Product());
                System.out.println(getName() + " produced a product.");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

3. **Consumer** 类：
- 从缓冲区消费产品并处理状态
- 也是通过 `synchronized` 关键字保证线程安全

public class Consumer extends Thread {
    private Product product;
    
    public Consumer(String name, Product prod) {
        super(name);
        this.product = prod;
    }

    @Override
    public void run() {
        while (true) {
            try {
                Product consumedProduct = product.consumeProduct();
                if (consumedProduct != null) {
                    System.out.println(getName() + " consumed a product.");
                } else {
                    break; // 没有产品可消费，退出循环
                }
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
        System.out.println(getName() + " has finished consuming.");
    }
}

为了启动这个模型，你可以创建多个生产者和消费者实例，并分别启动它们。例如：

public static void main(String[] args) {
    Product buffer = new Product();
    Producer producerA = new Producer("Producer A", buffer);
    Producer producerB = new Producer("Producer B", buffer);
    Consumer consumer1 = new Consumer("Consumer 1", buffer);
    Consumer consumer2 = new Consumer("Consumer 2", buffer);
    Consumer consumer3 = new Consumer("Consumer 3", buffer);

    producerA.start();
    producerB.start();
    consumer1.start();
    consumer2.start();
    consumer3.start();
}

运行这个程序，你会看到生产者和消费者的活动以及缓冲区的状态。