模拟生产者/消费者进程实现同步/互斥操作java窗口实现完整代码

以下是一个使用Java语言实现的生产者/消费者模型的完整代码，实现了同步和互斥操作：

import java.util.LinkedList;
import java.util.Queue;
import javax.swing.JFrame;
import javax.swing.JTextArea;

public class ProducerConsumer extends JFrame {
    private JTextArea output; // 用于显示输出信息的文本区域
    private Queue<Integer> buffer; // 缓冲区队列
    private final int BUFFER_SIZE = 5; // 缓冲区大小
    private final Object lock = new Object(); // 用于同步的锁对象

    public ProducerConsumer() {
        super("Producer/Consumer Demo");
        output = new JTextArea();
        add(output);
        setSize(300, 300);
        setVisible(true);
        buffer = new LinkedList<Integer>();
        new Producer().start();
        new Consumer().start();
    }

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

    // 生产者线程
    private class Producer extends Thread {
        public void run() {
            int item;
            while (true) {
                synchronized (lock) {
                    // 如果缓冲区已满，则等待
                    while (buffer.size() == BUFFER_SIZE) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    item = produceItem();
                    buffer.add(item);
                    output.append("Produced item " + item + "\n");
                    // 唤醒等待的消费者线程
                    lock.notifyAll();
                }
                // 生产完一个物品后随机休眠一段时间
                try {
                    Thread.sleep((int) (Math.random() * 3000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        // 生产一个物品
        private int produceItem() {
            return (int) (Math.random() * 100);
        }
    }

    // 消费者线程
    private class Consumer extends Thread {
        public void run() {
            int item;
            while (true) {
                synchronized (lock) {
                    // 如果缓冲区为空，则等待
                    while (buffer.size() == 0) {
                        try {
                            lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                    item = buffer.remove();
                    output.append("Consumed item " + item + "\n");
                    // 唤醒等待的生产者线程
                    lock.notifyAll();
                }
                // 消费完一个物品后随机休眠一段时间
                try {
                    Thread.sleep((int) (Math.random() * 3000));
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

在此代码中，我们使用了一个JTextArea对象来显示输出信息。缓冲区队列使用了Java集合框架中提供的LinkedList类，而同步和互斥操作则使用了Java中的synchronized关键字和wait()/notifyAll()方法。在程序运行时，我们创建了一个生产者线程和一个消费者线程，它们在同一个缓冲区队列上进行操作。当缓冲区已满时，生产者线程将等待，直到消费者线程取走一个物品，唤醒生产者线程；当缓冲区为空时，消费者线程将等待，直到生产者线程放入一个物品，唤醒消费者线程。通过这种方式，我们实现了生产者/消费者模型中的同步和互斥操作。