操作系统 —— 生产者消费者问题JAVA代码实现 [有比较完整的界面]

以下是一个基于Java的生产者消费者问题的代码实现，附带GUI界面：

import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.List;

public class ProducerConsumer extends JFrame implements ActionListener {

    private final int BUFFER_SIZE = 5; // 缓冲区大小
    private final List<Integer> buffer = new ArrayList<>(BUFFER_SIZE); // 缓冲区
    private final Object lock = new Object(); // 同步锁对象

    private final JLabel bufferLabel = new JLabel(); // 显示缓冲区的标签
    private final JTextField producerTextField = new JTextField(8); // 生产者输入框
    private final JTextField consumerTextField = new JTextField(8); // 消费者输入框
    private final JButton startButton = new JButton("开始"); // 开始按钮
    private final JButton stopButton = new JButton("停止"); // 停止按钮

    private Producer producer;
    private Consumer consumer;

    public ProducerConsumer() {
        setTitle("生产者消费者问题");
        setSize(400, 200);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        JPanel panel = new JPanel();
        panel.setLayout(new GridLayout(3, 2, 20, 10));
        panel.setBorder(BorderFactory.createEmptyBorder(20, 20, 20, 20));

        panel.add(new JLabel("缓冲区："));
        panel.add(bufferLabel);

        panel.add(new JLabel("生产者："));
        panel.add(producerTextField);

        panel.add(new JLabel("消费者："));
        panel.add(consumerTextField);

        startButton.addActionListener(this);
        stopButton.addActionListener(this);
        stopButton.setEnabled(false);

        panel.add(startButton);
        panel.add(stopButton);

        setContentPane(panel);
        setVisible(true);
    }

    @Override
    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == startButton) {
            // 点击开始按钮时，启动生产者和消费者线程
            producer = new Producer();
            consumer = new Consumer();
            producer.start();
            consumer.start();
            startButton.setEnabled(false);
            stopButton.setEnabled(true);
        } else if (e.getSource() == stopButton) {
            // 点击停止按钮时，停止生产者和消费者线程
            producer.stopThread();
            consumer.stopThread();
            startButton.setEnabled(true);
            stopButton.setEnabled(false);
        }
    }

    private void updateBufferLabel() {
        // 更新缓冲区标签的显示
        String bufferText = "";
        for (Integer item : buffer) {
            bufferText += item + " ";
        }
        bufferLabel.setText(bufferText);
    }

    private class Producer extends Thread {

        private boolean stop = false;

        public void stopThread() {
            stop = true;
        }

        @Override
        public void run() {
            while (!stop) {
                synchronized (lock) {
                    // 如果缓冲区已满，则等待
                    while (buffer.size() == BUFFER_SIZE) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    // 生产一个随机数，并添加到缓冲区
                    int item = (int) (Math.random() * 100);
                    buffer.add(item);
                    System.out.println("生产者生产了：" + item);
                    updateBufferLabel();
                    // 唤醒一个等待的线程（可能是消费者）
                    lock.notify();
                }
                try {
                    // 线程休眠一段时间，模拟生产过程
                    Thread.sleep((int) (Math.random() * 2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private class Consumer extends Thread {

        private boolean stop = false;

        public void stopThread() {
            stop = true;
        }

        @Override
        public void run() {
            while (!stop) {
                synchronized (lock) {
                    // 如果缓冲区为空，则等待
                    while (buffer.size() == 0) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    // 从缓冲区中取出一个元素，并消费它
                    int item = buffer.remove(buffer.size() - 1);
                    System.out.println("消费者消费了：" + item);
                    updateBufferLabel();
                    // 唤醒一个等待的线程（可能是生产者）
                    lock.notify();
                }
                try {
                    // 线程休眠一段时间，模拟消费过程
                    Thread.sleep((int) (Math.random() * 2000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

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

运行该程序，将会显示一个GUI界面，包括一个显示缓冲区的标签、两个输入框（分别用于生产者和消费者输入数据）、一个开始按钮和一个停止按钮。点击开始按钮，程序将启动一个生产者线程和一个消费者线程，并开始模拟生产者和消费者在缓冲区中的操作；点击停止按钮，程序将停止生产者和消费者线程，结束模拟过程。