有界缓冲区问题 - 生产者生成数据但消费者不消费它

Question

我正在编写一个绑定缓冲区程序，生产者根据缓冲区的大小生产数据，但消费者没有消费它，因此没有解决问题。我错过了什么？

缓冲类：

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

public class SharedBuffer {
    
    Queue<Integer> queue = new LinkedList<>();
    
    int bufferCapacity = 5;

}

制作人等级：

public class Producer extends SharedBuffer implements Runnable {
    
    @Override
    public void run() {
        int currentValue = 0;
        while(true) {
            synchronized(this){
                
                while(queue.size() == bufferCapacity) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
                System.out.println("Producer produced: " + currentValue);
                
                queue.add(currentValue++);
                
                notify();
                
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
    }

}

消费类：

public class Consumer extends SharedBuffer implements Runnable{

    @Override
    public void run() {
        // TODO Auto-generated method stub
        int currentItem;
        
        while(true) {
            synchronized(this) {
                
                while(queue.size() == 0) {
                    try {
                        wait();
                    } catch (InterruptedException e) {
                        // TODO Auto-generated catch block
                        e.printStackTrace();
                    }
                }
                
                currentItem = queue.remove();
                
                System.out.println("Consumer consumed: " + currentItem);
                
                notify();
                
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
        
    }

    
}

主要/驱动类：

public class driver {

    public static void main(String[] args) throws InterruptedException {
        // TODO Auto-generated method stub
        
        Producer producer = new Producer();
        Consumer consumer = new Consumer();
        
        Thread producerThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);
        
        consumerThread.start();
        producerThread.start();
        
        
        producerThread.join();
        consumerThread.join();

    }

}

输出（循环继续而不退出）：

Producer produced: 0
Producer produced: 1
Producer produced: 2
Producer produced: 3
Producer produced: 4

线程应该同步，以便缓冲区不会因生产者产生溢出数据而溢出，也不会因消费者试图消耗比现有数据更多的数据而下溢。

Answer 1

生产者和消费者类都扩展了 SharedBuffer 类，这样它们每个都有自己单独的队列实例 - 因此当您在生产者中添加新任务时，消费者看不到它们。

队列应该在生产者和消费者的实例之间共享。为此，将 SharedBuffer 的相同实例传递给 Producer 和 Consumer 类。下面是如何修改 main 方法的示例：

public class driver {

    public static void main(String[] args) throws InterruptedException {
        
        SharedBuffer sharedBuffer = new SharedBuffer();
        
        Producer producer = new Producer(sharedBuffer);
        Consumer consumer = new Consumer(sharedBuffer);
        
        Thread producerThread = new Thread(producer);
        Thread consumerThread = new Thread(consumer);
        
        consumerThread.start();
        producerThread.start();
        
        
        producerThread.join();
        consumerThread.join();

    }

}

...当然，修改 Producer 和 Consumer 类的构造函数以接受 SharedBuffer 实例并使用它，而不是创建新实例。