生产者消费者问题java Runnable

生产者消费者问题是一个经典的并发编程问题，原理是一个线程（或进程）生产某种数据，而另一个线程（或进程）则消费这些数据，这两个线程之间共享一个缓冲区。为了避免竞争条件，需要对缓冲区进行同步访问。

以下是使用Java Runnable接口实现生产者消费者问题的示例代码：

import java.util.LinkedList;

public class ProducerConsumerExample {

    public static void main(String[] args) {
        LinkedList<Integer> buffer = new LinkedList<>();
        int maxSize = 10;

        Runnable producer = new Producer(buffer, maxSize);
        Runnable consumer = new Consumer(buffer);

        Thread producerThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);

        producerThread.start();
        consumerThread.start();
    }

    static class Producer implements Runnable {
        private final LinkedList<Integer> buffer;
        private final int maxSize;

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

        @Override
        public void run() {
            while (true) {
                synchronized (buffer) {
                    while (buffer.size() == maxSize) {
                        try {
                            buffer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int number = (int) (Math.random() * 100);
                    buffer.add(number);
                    System.out.println("Producer produced " + number);
                    buffer.notifyAll();
                }
            }
        }
    }

    static class Consumer implements Runnable {
        private final LinkedList<Integer> buffer;

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

        @Override
        public void run() {
            while (true) {
                synchronized (buffer) {
                    while (buffer.isEmpty()) {
                        try {
                            buffer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    int number = buffer.removeFirst();
                    System.out.println("Consumer consumed " + number);
                    buffer.notifyAll();
                }
            }
        }
    }
}

在这个示例中，我们创建了一个缓冲区LinkedList，设置缓冲区的最大大小为10。然后，我们定义了一个Producer和Consumer类实现Runnable接口，并在它们的run()方法中实现了生产者和消费者的逻辑。

在Producer的run()方法中，我们使用了synchronized关键字同步访问缓冲区。如果缓冲区已满，生产者线程就会进入等待状态，直到消费者线程从缓冲区中取走一些数据，通知生产者线程继续生产。如果缓冲区还有空间，生产者线程就会生成一个随机数，并将其添加到缓冲区中，然后通知等待缓冲区非空的所有线程。

在Consumer的run()方法中，我们也使用了synchronized关键字同步访问缓冲区。如果缓冲区为空，消费者线程就会进入等待状态，直到生产者线程向缓冲区中添加一些数据，通知消费者线程继续消费。如果缓冲区中有数据，消费者线程就会从缓冲区中取出第一个数据，并通知等待缓冲区非满的所有线程。

最后，在main()方法中，我们创建了一个Producer和Consumer对象，并将它们分别传递给两个Thread对象。然后，我们启动这两个线程。运行程序时，你会看到生产者线程生成随机数，并将其添加到缓冲区中，而消费者线程则从缓冲区中取出数据并消费它们。