Java 我实施生产者消费者问题的方法正确吗？

我已经使用wait/notify组合实现了生产者问题。请有人告诉我，我对生产者-消费者问题的理解是否正确，我的实施是否正确/优化

现在我正在考虑如何使用

ExecutorService

和

CountDownLatch

，

ReentrantLock

，

CyclicBarrier

实现相同的问题？有什么办法吗？同时，我将尝试看看是否可以使用闩锁实现问题解决方案

import java.util.ArrayList;
import java.util.EmptyStackException;
import java.util.Random;

public class ProducerConsumerProblem {

    private Object syncher = new Object();
    private volatile ArrayList<Integer> sharedBuffer = new ArrayList<Integer>();

    public static void main(String[] args) {

        ProducerConsumerProblem object = new ProducerConsumerProblem();

        Thread producerThread = new Thread(() -> {
            object.produceData();
        },"Producer");
        Thread consumerThread = new Thread(() -> {
            object.consumeData();
        },"Consumer");
        producerThread.start();
        consumerThread.start();
    }

    public void produceData() {
        Random randomNumber = new Random();
        while(true) {
            synchronized (syncher) {
                if(sharedBuffer.size() == 1) {
                    try {
                        //System.out.println("Producer waiting...");
                        syncher.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Integer producedElem = randomNumber.nextInt(10);
                System.out.println("+++ Produced: "+producedElem);
                sharedBuffer.add(producedElem);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                syncher.notify();
            }
        }
    }

    public void consumeData() {
        while(true) {
            synchronized (syncher) {
                while(sharedBuffer.size() == 0) {
                    try {
                        //System.out.println("Consumer waiting...");
                        syncher.wait();
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                Integer consumedElem = sharedBuffer.stream().findAny().orElseThrow(()-> new EmptyStackException());
                System.out.println("--- Consumed: "+consumedElem);
                sharedBuffer.remove(consumedElem);
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                syncher.notify();
            }
        }
    }
}

import java.util.ArrayList；
导入java.util.EmptyStackException；
导入java.util.Random；
公共类生产者消费者问题{
私有对象同步器=新对象（）；
private volatile ArrayList sharedBuffer=new ArrayList（）；
公共静态void main（字符串[]args）{
ProducerConsumerProblem对象=新的ProducerConsumerProblem（）；
线程生成器读取=新线程（（）->{
object.produceData（）；
}“生产者”）；
线程使用者读取=新线程（（）->{
object.consumerdata（）；
}“消费者”）；
producerThread.start（）；
consumerThread.start（）；
}
public void produceData（）{
随机数=新随机数（）；
while（true）{
已同步（同步）{
if（sharedBuffer.size（）=1）{
试一试{
//System.out.println（“生产者等待…”）；
syncher.wait（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
整数producedElem=randomNumber.nextInt（10）；
System.out.println（“+++生产：“+producedElem”）；
sharedBuffer.add（producedElem）；
试一试{
《睡眠》（2000年）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
syncher.notify（）；
}
}
}
公共数据（）{
while（true）{
已同步（同步）{
while（sharedBuffer.size（）=0）{
试一试{
//System.out.println（“消费者等待…”）；
syncher.wait（）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
整数consumedElem=sharedBuffer.stream（）.findAny（）.OrelsThrow（（）->new EmptyStackException（））；
System.out.println（“--consumered:+consumerdelem”）；
sharedBuffer.remove（consumedElem）；
试一试{
《睡眠》（2000年）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
syncher.notify（）；
}
}
}
}

导入java.util.Random；
导入java.util.concurrent.ArrayBlockingQueue；
导入java.util.concurrent.BlockingQueue；
公共类ProducerConsumerProblemingBlockingQueue{
BlockingQueue BlockingQueue=新阵列BlockingQueue（1）；
公共静态void main（字符串[]args）{
ProducerConsumerProblemingBlockingQueue对象=新建ProducerConsumerProblemingBlockingQueue（）；
线程生成器读取=新线程（（）->{
object.produceData（object.blockingQueue）；
}“生产者”）；
线程使用者读取=新线程（（）->{
object.consumerdata（object.blockingQueue）；
}“消费者”）；
consumerThread.start（）；
producerThread.start（）；
}
私有无效数据（BlockingQueue BlockingQueue）{
对于（int i=0；i<10；i++）{
试一试{
System.out.println（“已消费：+blockingQueue.take（）.intValue（））；
《睡眠》（2000年）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
私有void produceData（BlockingQueue BlockingQueue）{
Random randomObject=新的Random（）；
对于（int i=0；i<10；i++）{
试一试{
int randomNumber=randomObject.nextInt（100）；
System.out.println（“生成：+随机数）；
blockingQueue.put（随机数）；
《睡眠》（2000年）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
}

为什么不使用BlockingQueue的标准实现？@AlexeiKaigorodov:我试图首先使用wait/notify实现，然后将通过BlockingQueue、CountDownLatch、ReentrantLock继续实现，CyclicBarrier你应该在@AlexeiKaigorodov上发布：使用BlockingQueue解决生产者-消费者问题的答案正确吗？@ManishAdhikari是的。唯一的备注：“.intValue（）”是多余的。

import java.util.Random;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class ProducerConsumerProblemUsingBlockingQueue {

    BlockingQueue<Integer> blockingQueue = new ArrayBlockingQueue<Integer>(1);

    public static void main(String[] args) {

        ProducerConsumerProblemUsingBlockingQueue object = new ProducerConsumerProblemUsingBlockingQueue();

        Thread producerThread = new Thread(() -> {
            object.produceData(object.blockingQueue);
        },"Producer");
        Thread consumerThread = new Thread(() -> {
            object.consumeData(object.blockingQueue);
        },"Consumer");
        consumerThread.start();
        producerThread.start();
    }

    private void consumeData(BlockingQueue<Integer> blockingQueue) {
        for(int i = 0; i < 10; i++) {
            try {
                System.out.println("Consumed: "+blockingQueue.take().intValue());
                Thread.sleep(2000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

    private void produceData(BlockingQueue<Integer> blockingQueue) {
        Random randomObject = new Random();
        for(int i = 0; i < 10; i++) {
            try {
                int randomNumber = randomObject.nextInt(100);
                System.out.println("Produced: "+randomNumber);
                blockingQueue.put(randomNumber);
                Thread.sleep(2000);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}