操作系统生产者与消费者问题代码实现

以下是生产者与消费者问题的Java代码实现：

import java.util.LinkedList;
import java.util.Random;

public class ProducerConsumer {

    private LinkedList<Integer> buffer = new LinkedList<>();
    private int maxSize = 10;

    public void produce() throws InterruptedException {
        while (true) {
            synchronized (this) {
                while (buffer.size() == maxSize) {
                    wait();
                }
                Random random = new Random();
                int num = random.nextInt(100);
                buffer.add(num);
                System.out.println("Produced: " + num);
                notify();
            }
            Thread.sleep(1000);
        }
    }

    public void consume() throws InterruptedException {
        while (true) {
            synchronized (this) {
                while (buffer.size() == 0) {
                    wait();
                }
                int num = buffer.removeFirst();
                System.out.println("Consumed: " + num);
                notify();
            }
            Thread.sleep(1000);
        }
    }

    public static void main(String[] args) {
        ProducerConsumer pc = new ProducerConsumer();

        Thread producerThread = new Thread(() -> {
            try {
                pc.produce();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

        Thread consumerThread = new Thread(() -> {
            try {
                pc.consume();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        });

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

在上述代码中， `buffer` 表示缓冲区，`maxSize` 表示缓冲区最大容量。`produce` 方法中的 `synchronized` 用于实现线程同步，`wait` 用于使生产者线程等待，`notify` 用于唤醒其他线程。`consume` 方法同理。

在 `main` 方法中，创建了一个 `ProducerConsumer` 实例 `pc`，并创建了一个生产者线程和一个消费者线程，分别调用 `produce` 和 `consume` 方法。

运行该程序，可以看到生产者和消费者交替运行，并输出生产和消费的数字。当缓冲区达到最大容量时，生产者线程等待；当缓冲区为空时，消费者线程等待。这样就完成了生产者与消费者问题的实现。