Java 生产者-消费者问题实现：线程同步与互斥、图形化界面

由于生产者-消费者问题是一个经典的并发编程问题，本题解只提供一个参考的实现思路和代码框架，具体实现细节和图形化界面的实现可以根据具体需求自行实现。

实现思路：

定义一个共享的缓冲区，用于存储生产者生产的数据和消费者消费的数据。
定义一个生产者类，该类实现 Runnable 接口，重写 run() 方法，在该方法中使用 synchronized 关键字对共享缓冲区进行加锁，生产者将生产的数据加入缓冲区，然后唤醒所有等待线程，并释放锁。
定义一个消费者类，该类实现 Runnable 接口，重写 run() 方法，在该方法中使用 synchronized 关键字对共享缓冲区进行加锁，消费者从缓冲区取出数据进行消费，然后唤醒所有等待线程，并释放锁。
在主线程中创建一个共享的缓冲区对象和若干个生产者对象和消费者对象，然后启动所有线程。
可以通过图形化界面实现对生产者和消费者的控制，例如可以设置生产者和消费者的数量、缓冲区的大小等。

代码框架：

import java.util.LinkedList;

public class Buffer {
    private LinkedList<Object> buffer;
    private int maxSize;

    public Buffer(int maxSize) {
        buffer = new LinkedList<>();
        this.maxSize = maxSize;
    }

    public synchronized void put(Object obj) throws InterruptedException {
        while(buffer.size() == maxSize) {
            wait();
        }
        buffer.add(obj);
        notifyAll();
    }

    public synchronized Object take() throws InterruptedException {
        while(buffer.size() == 0) {
            wait();
        }
        Object obj = buffer.remove();
        notifyAll();
        return obj;
    }
}

public class Producer implements Runnable {
    private Buffer buffer;

    public Producer(Buffer buffer) {
        this.buffer = buffer;
    }

    public void run() {
        try {
            while(true) {
                Object obj = produce();
                buffer.put(obj);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private Object produce() {
        // 生产数据的逻辑
    }
}

public class Consumer implements Runnable {
    private Buffer buffer;

    public Consumer(Buffer buffer) {
        this.buffer = buffer;
    }

    public void run() {
        try {
            while(true) {
                Object obj = buffer.take();
                consume(obj);
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    private void consume(Object obj) {
        // 消费数据的逻辑
    }
}

public class Main {
    public static void main(String[] args) {
        Buffer buffer = new Buffer(10);
        int numProducers = 5;
        int numConsumers = 5;

        // 创建生产者线程
        for(int i = 0; i < numProducers; i++) {
            Producer producer = new Producer(buffer);
            Thread thread = new Thread(producer);
            thread.start();
        }

        // 创建消费者线程
        for(int i = 0; i < numConsumers; i++) {
            Consumer consumer = new Consumer(buffer);
            Thread thread = new Thread(consumer);
            thread.start();
        }
    }
}