Java 生产者-消费者问题实现：带图形界面和可配置生产者/消费者数量

以下是一个简单的生产者-消费者问题的 Java 代码实现，包含了界面图形化的部分，可以输入生产者消费者数量：

import java.awt.*;
import java.awt.event.*;
import javax.swing.*;

public class ProducerConsumer extends JFrame implements ActionListener {
    private JLabel producerLabel, consumerLabel;
    private JTextField producerField, consumerField;
    private JButton startButton, stopButton;
    private JTextArea outputArea;

    private int producerCount, consumerCount;

    private ProducerThread[] producerThreads;
    private ConsumerThread[] consumerThreads;

    private Buffer buffer;

    public ProducerConsumer() {
        super('Producer-Consumer');

        producerLabel = new JLabel('Producers:');
        producerField = new JTextField('1', 5);
        consumerLabel = new JLabel('Consumers:');
        consumerField = new JTextField('1', 5);

        startButton = new JButton('Start');
        startButton.addActionListener(this);
        stopButton = new JButton('Stop');
        stopButton.addActionListener(this);

        outputArea = new JTextArea(10, 40);

        JPanel inputPanel = new JPanel(new FlowLayout());
        inputPanel.add(producerLabel);
        inputPanel.add(producerField);
        inputPanel.add(consumerLabel);
        inputPanel.add(consumerField);
        inputPanel.add(startButton);
        inputPanel.add(stopButton);

        JScrollPane outputScroll = new JScrollPane(outputArea);

        Container container = getContentPane();
        container.add(inputPanel, BorderLayout.NORTH);
        container.add(outputScroll, BorderLayout.CENTER);

        producerCount = 1;
        consumerCount = 1;

        setSize(500, 300);
        setVisible(true);

        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    }

    public void actionPerformed(ActionEvent e) {
        if (e.getSource() == startButton) {
            producerCount = Integer.parseInt(producerField.getText());
            consumerCount = Integer.parseInt(consumerField.getText());

            buffer = new Buffer();

            producerThreads = new ProducerThread[producerCount];
            for (int i = 0; i < producerCount; i++) {
                producerThreads[i] = new ProducerThread(buffer, 'Producer ' + i);
                producerThreads[i].start();
            }

            consumerThreads = new ConsumerThread[consumerCount];
            for (int i = 0; i < consumerCount; i++) {
                consumerThreads[i] = new ConsumerThread(buffer, 'Consumer ' + i);
                consumerThreads[i].start();
            }

            startButton.setEnabled(false);
            stopButton.setEnabled(true);
        } else if (e.getSource() == stopButton) {
            for (int i = 0; i < producerCount; i++) {
                producerThreads[i].stopThread();
            }

            for (int i = 0; i < consumerCount; i++) {
                consumerThreads[i].stopThread();
            }

            startButton.setEnabled(true);
            stopButton.setEnabled(false);
        }
    }

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

    private class Buffer {
        private static final int BUFFER_SIZE = 5;

        private int[] buffer = new int[BUFFER_SIZE];
        private int count = 0;

        public synchronized void put(int value) throws InterruptedException {
            while (count == BUFFER_SIZE) {
                wait();
            }

            buffer[count++] = value;

            outputArea.append(Thread.currentThread().getName() + ' produced ' + value + '\n');

            notifyAll();
        }

        public synchronized int get() throws InterruptedException {
            while (count == 0) {
                wait();
            }

            int value = buffer[--count];

            outputArea.append(Thread.currentThread().getName() + ' consumed ' + value + '\n');

            notifyAll();

            return value;
        }
    }

    private abstract class ThreadWithStopFlag extends Thread {
        private boolean stopFlag = false;

        public void stopThread() {
            stopFlag = true;
        }

        public boolean isStopped() {
            return stopFlag;
        }
    }

    private class ProducerThread extends ThreadWithStopFlag {
        private Buffer buffer;

        public ProducerThread(Buffer buffer, String name) {
            super(name);
            this.buffer = buffer;
        }

        public void run() {
            try {
                int i = 0;

                while (!isStopped()) {
                    buffer.put(i++);
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                // do nothing
            }
        }
    }

    private class ConsumerThread extends ThreadWithStopFlag {
        private Buffer buffer;

        public ConsumerThread(Buffer buffer, String name) {
            super(name);
            this.buffer = buffer;
        }

        public void run() {
            try {
                while (!isStopped()) {
                    int value = buffer.get();
                    Thread.sleep(1000);
                }
            } catch (InterruptedException e) {
                // do nothing
            }
        }
    }
}