生产者消费者图形化演示

好的，这是一个简单的生产者消费者图形化演示：


在这个演示中，有三个进程：一个生产者和两个消费者，它们共享一个缓冲区。生产者不断地生成数据并将其放入缓冲区中，而消费者则从缓冲区中取出数据并处理。当缓冲区已满时，生产者将被阻塞，直到有空间可用为止。同样，当缓冲区为空时，消费者也会被阻塞，直到有数据可用为止。这个演示可以很好地展示生产者消费者问题中的同步和互斥问题。

相关问题

生产者消费者图形化演示Java实现

好的，这是一个简单的Java实现的生产者消费者图形化演示：

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

import javax.swing.JFrame;
import javax.swing.JLabel;

public class ProducerConsumerDemo extends JFrame {
    private static final long serialVersionUID = 1L;
    private static final int BUFFER_SIZE = 10;
    private static final int MAX_SLEEP_TIME = 3000;
    private static final int MAX_PRODUCE_TIMES = 20;
    private static final int MAX_CONSUME_TIMES = 20;

    private Queue<Integer> buffer;
    private JLabel bufferLabel;

    public ProducerConsumerDemo() {
        setTitle("Producer Consumer Demo");
        setSize(400, 400);
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setLayout(null);

        JLabel producerLabel = new JLabel("Producer");
        producerLabel.setBounds(50, 50, 100, 30);
        add(producerLabel);

        JLabel consumer1Label = new JLabel("Consumer 1");
        consumer1Label.setBounds(50, 100, 100, 30);
        add(consumer1Label);

        JLabel consumer2Label = new JLabel("Consumer 2");
        consumer2Label.setBounds(50, 150, 100, 30);
        add(consumer2Label);

        bufferLabel = new JLabel();
        bufferLabel.setBounds(200, 50, 100, 130);
        add(bufferLabel);

        buffer = new LinkedList<Integer>();

        Producer producer = new Producer();
        Consumer consumer1 = new Consumer(1);
        Consumer consumer2 = new Consumer(2);

        producer.start();
        consumer1.start();
        consumer2.start();

        setVisible(true);
    }

    private class Producer extends Thread {
        private Random random = new Random();

        @Override
        public void run() {
            int count = 0;
            while (count < MAX_PRODUCE_TIMES) {
                int value = random.nextInt(100);
                synchronized (buffer) {
                    while (buffer.size() == BUFFER_SIZE) {
                        try {
                            buffer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    buffer.offer(value);
                    bufferLabel.setText(buffer.toString());
                    buffer.notifyAll();
                }
                count++;
                try {
                    sleep(random.nextInt(MAX_SLEEP_TIME));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

    private class Consumer extends Thread {
        private int id;
        private Random random = new Random();

        public Consumer(int id) {
            this.id = id;
        }

        @Override
        public void run() {
            int count = 0;
            while (count < MAX_CONSUME_TIMES) {
                int value;
                synchronized (buffer) {
                    while (buffer.isEmpty()) {
                        try {
                            buffer.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    value = buffer.poll();
                    bufferLabel.setText(buffer.toString());
                    buffer.notifyAll();
                }
                System.out.println("Consumer " + id + " consumed " + value);
                count++;
                try {
                    sleep(random.nextInt(MAX_SLEEP_TIME));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }

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

在这个实现中，我们使用了Java的多线程机制来模拟生产者消费者问题。我们使用一个队列来充当缓冲区，并使用`synchronized`关键字来保证线程的同步和互斥。当缓冲区已满时，生产者线程将被阻塞，直到有空间可用为止；当缓冲区为空时，消费者线程将被阻塞，直到有数据可用为止。我们使用`wait()`和`notifyAll()`方法来实现这种同步机制。同时，我们还使用了Java的图形化界面来展示缓冲区的状态，以便更好地理解整个过程。

利用C++实现生产者消费者图形化演示

生产者消费者问题是一个经典的并发编程问题，可以通过多线程来实现。下面是一个基于C++的生产者消费者图形化演示程序的简单实现：

#include <iostream>
#include <queue>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <chrono>
#include <vector>
#include <SFML/Graphics.hpp>

const int WINDOW_WIDTH = 800;
const int WINDOW_HEIGHT = 600;
const int BUFFER_SIZE = 5;
const int PRODUCER_NUM = 2;
const int CONSUMER_NUM = 2;
const int ITEM_SIZE = 20;
const int ITEM_GAP = 10;
const int ITEM_ROW_GAP = 50;
const int ITEM_COL_GAP = 10;
const int ITEM_START_X = 30;
const int ITEM_START_Y = 100;

struct Item {
    int id;
    sf::RectangleShape shape;

    Item(int id) : id(id) {
        shape.setSize(sf::Vector2f(ITEM_SIZE, ITEM_SIZE));
        shape.setFillColor(sf::Color::Green);
        shape.setOutlineThickness(2);
        shape.setOutlineColor(sf::Color::Cyan);
    }

    void setPosition(int x, int y) {
        shape.setPosition(sf::Vector2f(x, y));
    }
};

std::queue<Item> buffer;
std::mutex mutex;
std::condition_variable not_full;
std::condition_variable not_empty;
bool done = false;

void producer(int id) {
    while (!done) {
        std::unique_lock<std::mutex> lock(mutex);
        not_full.wait(lock, []{ return buffer.size() < BUFFER_SIZE; });

        Item item(buffer.size() + 1);
        item.setPosition(ITEM_START_X + (ITEM_SIZE + ITEM_GAP) * buffer.size(),
                          ITEM_START_Y + ITEM_ROW_GAP * id + ITEM_COL_GAP * id);

        buffer.push(item);
        not_empty.notify_all();

        lock.unlock();

        std::this_thread::sleep_for(std::chrono::milliseconds(500));
    }
}

void consumer(int id) {
    while (!done) {
        std::unique_lock<std::mutex> lock(mutex);
        not_empty.wait(lock, []{ return !buffer.empty(); });

        buffer.pop();
        not_full.notify_all();

        lock.unlock();

        std::this_thread::sleep_for(std::chrono::milliseconds(1000));
    }
}

int main() {
    sf::RenderWindow window(sf::VideoMode(WINDOW_WIDTH, WINDOW_HEIGHT), "Producer-Consumer Demo");

    std::vector<std::thread> producers;
    std::vector<std::thread> consumers;

    for (int i = 0; i < PRODUCER_NUM; i++) {
        producers.emplace_back(producer, i);
    }

    for (int i = 0; i < CONSUMER_NUM; i++) {
        consumers.emplace_back(consumer, i);
    }

    while (window.isOpen()) {
        sf::Event event;
        while (window.pollEvent(event)) {
            if (event.type == sf::Event::Closed) {
                done = true;
            }
        }

        window.clear(sf::Color::White);

        std::unique_lock<std::mutex> lock(mutex);
        for (auto& item : buffer) {
            window.draw(item.shape);
        }
        lock.unlock();

        window.display();
    }

    for (auto& producer : producers) {
        producer.join();
    }

    for (auto& consumer : consumers) {
        consumer.join();
    }

    return 0;
}

这个程序使用 SFML 库来实现图形化界面，其中 `Item` 结构体表示生产者生产的物品，包含一个 ID 和一个矩形形状。生产者线程在等待缓冲区不满时生产物品并将其加入缓冲区，然后通知消费者线程。消费者线程在等待缓冲区不空时从中取出一个物品并通知生产者线程。主线程循环绘制缓冲区中的物品，并在接收到关闭窗口事件时结束生产者消费者线程的运行。