生产者消费者图形化实现

生产者消费者问题是一个经典的并发编程问题，可以通过图形化界面来演示其实现过程。下面是一个简单的 Java Swing 实现示例：

首先，我们需要定义一个商品类，用于表示生产者和消费者生产和消费的物品。

class Item {
    private int id;
    public Item(int id) {
        this.id = id;
    }
    public int getId() {
        return id;
    }
    public String toString() {
        return "Item " + id;
    }
}

然后，我们创建一个主界面类，它包含一个生产者和一个消费者线程，以及一个商品缓冲区。主界面中有一个生产按钮和一个消费按钮，点击按钮可以启动或停止相应的线程。

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

class MainFrame extends JFrame implements ActionListener {
    private Producer producer;
    private Consumer consumer;
    private ItemBuffer buffer;
    private JButton produceBtn, consumeBtn;

    public MainFrame() {
        producer = new Producer();
        consumer = new Consumer();
        buffer = new ItemBuffer();

        setTitle("Producer-Consumer Problem");
        setSize(400, 300);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        Container contentPane = getContentPane();
        contentPane.setLayout(new FlowLayout());

        produceBtn = new JButton("Produce");
        produceBtn.addActionListener(this);
        contentPane.add(produceBtn);

        consumeBtn = new JButton("Consume");
        consumeBtn.addActionListener(this);
        contentPane.add(consumeBtn);

        setVisible(true);
    }

    public void actionPerformed(ActionEvent event) {
        Object source = event.getSource();
        if (source == produceBtn) {
            if (producer.isRunning()) {
                producer.stop();
                produceBtn.setText("Produce");
            } else {
                producer.start();
                produceBtn.setText("Stop");
            }
        } else if (source == consumeBtn) {
            if (consumer.isRunning()) {
                consumer.stop();
                consumeBtn.setText("Consume");
            } else {
                consumer.start();
                consumeBtn.setText("Stop");
            }
        }
    }

    public void print(String message) {
        System.out.println(message);
    }

    private class Producer extends Thread {
        private boolean running = false;
        public boolean isRunning() {
            return running;
        }
        public void run() {
            running = true;
            while (running) {
                Item item = new Item((int)(Math.random() * 100));
                buffer.put(item);
                print("Producer produced " + item);
                try {
                    Thread.sleep((int)(Math.random() * 1000));
                } catch (InterruptedException e) {}
            }
        }
        public void stop() {
            running = false;
        }
    }

    private class Consumer extends Thread {
        private boolean running = false;
        public boolean isRunning() {
            return running;
        }
        public void run() {
            running = true;
            while (running) {
                Item item = buffer.get();
                print("Consumer consumed " + item);
                try {
                    Thread.sleep((int)(Math.random() * 1000));
                } catch (InterruptedException e) {}
            }
        }
        public void stop() {
            running = false;
        }
    }

    private class ItemBuffer {
        private static final int BUFFER_SIZE = 10;
        private Item[] buffer;
        private int head = 0, tail = 0, count = 0;

        public ItemBuffer() {
            buffer = new Item[BUFFER_SIZE];
        }

        public synchronized void put(Item item) {
            while (count == BUFFER_SIZE) {
                try {
                    wait();
                } catch (InterruptedException e) {}
            }
            buffer[tail] = item;
            tail = (tail + 1) % BUFFER_SIZE;
            count++;
            notifyAll();
        }

        public synchronized Item get() {
            while (count == 0) {
                try {
                    wait();
                } catch (InterruptedException e) {}
            }
            Item item = buffer[head];
            head = (head + 1) % BUFFER_SIZE;
            count--;
            notifyAll();
            return item;
        }
    }

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

这个示例中，我们使用了一个商品缓冲区来存储生产者生产的商品，消费者从缓冲区中取出商品进行消费。当缓冲区已满时，生产者线程会等待，直到有商品被取出；当缓冲区为空时，消费者线程会等待，直到有商品被放入。

点击生产按钮或消费按钮时，会启动或停止相应的线程。在控制台输出中可以看到生产者生产的商品和消费者消费的商品。