Java线程生产者消费者：代码有什么问题？

Question

尝试学习线程的多线程和进程间通信。实施了一个典型的生产者-消费者问题。然而，am获得的输出是相当连续的，这在理想情况下不应该是使用线程的情况。

好的，下面是完整的代码：

public class ProducerConsumerSimulation {


public static ProducerConsumerSimulation simulation = new ProducerConsumerSimulation();


private Queue<Integer> sharedQueue = new LinkedList<Integer>();

private int MAX_LIMIT =  10;

public void produce(int i){
    synchronized (sharedQueue) {
        while(true){


            while(sharedQueue.size()==MAX_LIMIT){
                try {
                    sharedQueue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } 
            sharedQueue.add(i);
            System.out.println("Produced: "+i);
            sharedQueue.notifyAll();
            return;


        }
    }
}

public void consume() {
    synchronized (sharedQueue) {
        while (true) {


            while (sharedQueue.isEmpty()) {
                try {
                    sharedQueue.wait();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            } 
            int i = sharedQueue.remove();
            System.out.println("Consumed: " + i);
            sharedQueue.notifyAll();
            return;


        }
    }
}

/**
 * @param args
 */
public static void main(String[] args) {


    for(int i=1;i<=5;i++){

        Runnable p = new Producer();
        Thread prod = new Thread(p);
        prod.start();
    }
    for(int i=1;i<=5;i++){

        Runnable c = new Consumer();
        Thread con = new Thread(c);
        con.start();
    }


}

}

生产者线程：

public class Producer implements Runnable {

/* (non-Javadoc)
 * @see java.lang.Runnable#run()
 */
@Override
public void run() {

    for(int i=1;i<=10;i++){
        ProducerConsumerSimulation.simulation.produce(i);
    }

}

}

使用者线程：

public class Consumer implements Runnable {

/* (non-Javadoc)
 * @see java.lang.Runnable#run()
 */
@Override
public void run() {

    for(int i=1;i<=10;i++){
        ProducerConsumerSimulation.simulation.consume();
    }

}

}

现在，当我运行程序时，生产者线程总是比消费者线程先运行。即使我创建了多个生产者/消费者，结果也是一样的。以下是单个生产者和单个消费者的产量：

Produced: 1
Produced: 2
Produced: 3
Produced: 4
Produced: 5
Produced: 6
Produced: 7
Produced: 8
Produced: 9
Produced: 10
Consumed: 1
Consumed: 2
Consumed: 3
Consumed: 4
Consumed: 5
Consumed: 6
Consumed: 7
Consumed: 8
Consumed: 9
Consumed: 10

有人能解释一下这里的行为吗？我已经在这里读了很多答案，但我想知道我是否错误地执行了或其他。

Answer 1

首先，您应该删除这两个while(true)循环，它们实际上只执行一次，因为您在第一次迭代后返回。它使您的代码相当混乱。

现在，关于您的问题：生产者和消费者在两个生产/消费之间都不做任何事情。它们立即重新进入同步块，以便将某些内容放入队列/从队列中获取某些内容。更实际的例子是在将值放入队列之前需要一些时间来生成这些值，并且需要一些时间来处理从队列中获得的值。如果在每次调用produce（）或consumer（）之后引入任意延迟，您将开始看到更多交错的生产和消耗。

最后，请注意，通过使用LinkedList、synchronized块和对wait/notifyAll的调用，您正在重新设计轮子。您应该只使用BlockingQueue，这对您来说就够了。