生产者消费者问题用java并且生产者类和消费者类都继承 Runnable类并给出注释

生产者消费者问题是一个经典的多线程问题，主要涉及到共享资源的问题。在该问题中，生产者和消费者共享一个缓冲区，生产者向缓冲区中生产产品，而消费者从缓冲区中消费产品。由于缓冲区的大小有限，因此需要进行同步控制，以避免生产者在缓冲区已满时继续生产，或者消费者在缓冲区为空时继续消费。

下面是一个使用 Java 实现的生产者消费者问题的示例代码，其中生产者和消费者类都继承了 Runnable 类，并给出了注释。

import java.util.LinkedList;

public class ProducerConsumerDemo {

    public static void main(String[] args) {
        // 创建一个共享缓冲区
        LinkedList<Integer> buffer = new LinkedList<Integer>();

        // 创建两个生产者和两个消费者
        Producer producer1 = new Producer(buffer);
        Producer producer2 = new Producer(buffer);
        Consumer consumer1 = new Consumer(buffer);
        Consumer consumer2 = new Consumer(buffer);

        // 创建四个线程并启动
        new Thread(producer1).start();
        new Thread(producer2).start();
        new Thread(consumer1).start();
        new Thread(consumer2).start();
    }

    // 生产者类
    static class Producer implements Runnable {
        private LinkedList<Integer> buffer;
        private int maxSize = 10;

        public Producer(LinkedList<Integer> buffer) {
            this.buffer = buffer;
        }

        public void run() {
            while (true) {
                synchronized (buffer) {
                    // 如果缓冲区已满，等待消费者消费
                    while (buffer.size() == maxSize) {
                        try {
                            System.out.println("缓冲区已满，" + Thread.currentThread().getName() + " 等待消费");
                            buffer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    // 生产一个产品，并通知消费者消费
                    int product = (int) (Math.random() * 100);
                    buffer.add(product);
                    System.out.println(Thread.currentThread().getName() + " 生产了产品 " + product);
                    buffer.notifyAll();
                }

                // 生产完一个产品后休眠一段时间
                try {
                    Thread.sleep((int) (Math.random() * 1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    // 消费者类
    static class Consumer implements Runnable {
        private LinkedList<Integer> buffer;

        public Consumer(LinkedList<Integer> buffer) {
            this.buffer = buffer;
        }

        public void run() {
            while (true) {
                synchronized (buffer) {
                    // 如果缓冲区为空，等待生产者生产
                    while (buffer.isEmpty()) {
                        try {
                            System.out.println("缓冲区为空，" + Thread.currentThread().getName() + " 等待生产");
                            buffer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }

                    // 从缓冲区中取出一个产品，并通知生产者生产
                    int product = buffer.removeFirst();
                    System.out.println(Thread.currentThread().getName() + " 消费了产品 " + product);
                    buffer.notifyAll();
                }

                // 消费完一个产品后休眠一段时间
                try {
                    Thread.sleep((int) (Math.random() * 1000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在该示例代码中，我们使用了 LinkedList 来作为共享缓冲区。生产者和消费者类都实现了 Runnable 接口，并重写了 run() 方法。在 run() 方法中，我们使用 synchronized 和 wait()、notifyAll() 来进行同步控制。当缓冲区已满时，生产者等待消费者消费；当缓冲区为空时，消费者等待生产者生产。同时，为了模拟实际情况，我们在生产和消费产品之后都加上了一定的休眠时间。