Java 如何根据生产者线程状态停止消费者线程

我需要实现一个消费者-生产者示例。这是一个简单的程序，我修改了一点，但我不确定它是否有潜在的问题。如果有人能帮我改进，我将不胜感激。我的主要 现在的问题是，我不知道如何阻止消费者当生产者完成

我尝试了以下代码，但stop（）已被弃用，而且也无法工作：

    if (!producer.isAlive()) {
            consumer.stop();
    }

ProducerConsumer.java：

    import java.util.Vector;

    public class ProducerConsumer {
        public static void main(String[] args) {
            int size = 5;
            Vector<Integer> sQ = new Vector<Integer>(size);
            Thread consumer = new Thread(new Consumer(sQ, size));
            Thread producer = new Thread(new Producer(sQ, size));
            consumer.start();
            producer.start();

            if (!producer.isAlive()) {
                consumer.stop();
            }
        }
    }

    class Consumer implements Runnable {
        Vector<Integer> sQ = new Vector<Integer>();
        int size;

        public Consumer(Vector<Integer> sQ, int size) {
            this.sQ = sQ;
            this.size = size;
        }

        @Override
        public void run() {
            while (true) {
                try {
                    System.out.println("Consuming element: " + consume());;
                    Thread.sleep(50);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }

        }

        private int consume() throws InterruptedException {
            synchronized (sQ) {

                while (sQ.isEmpty()) {
                    System.out.println("The queue is empty and "
                            + Thread.currentThread().getName() + " has to wait."
                            + "size is: " + sQ.size());
                    sQ.wait();
                }

                sQ.notifyAll();
                return sQ.remove(0);
            }

        }

    }

    class Producer implements Runnable {
        Vector<Integer> sQ = new Vector<Integer>();
        int size;

        public Producer(Vector<Integer> sQ, int size) {
            this.sQ = sQ;
            this.size = size;
        }

        @Override
        public void run() {
            for (int i = 0; i < 12; ++i) {
                try {
                    produce(i);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }

        private void produce(int i) throws InterruptedException {

            synchronized (sQ) {
                while (sQ.size() == size) {
                    System.out.println("The queue is full and "
                            + Thread.currentThread().getName() + " has to wait."
                            + "size is: " + sQ.size());
                    sQ.wait();
                }

                sQ.add(i);
                sQ.notify();
            }

        }
    }

import java.util.Vector；
公共类生产者消费者{
公共静态void main（字符串[]args）{
int size=5；
矢量sQ=新矢量（大小）；
螺纹耗电元件=新螺纹（新耗电元件（sQ，尺寸））；
线程生成器=新线程（新生成器（sQ，大小））；
consumer.start（）；
producer.start（）；
如果（！producer.isAlive（））{
消费者。停止（）；
}
}
}
类使用者实现Runnable{
向量sQ=新向量（）；
整数大小；
公共消费者（矢量平方，整数大小）{
这个.sQ=sQ；
这个。大小=大小；
}
@凌驾
公开募捐{
while（true）{
试一试{
System.out.println（“消费元素：+consume（））；；
睡眠（50）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
private int consume（）抛出InterruptedException{
同步（sQ）{
while（sQ.isEmpty（））{
System.out.println（“队列为空且”
+Thread.currentThread（）.getName（）+“必须等待。”
+尺寸为：“+sQ.size（））；
sQ.wait（）；
}
sQ.notifyAll（）；
返回sQ.remove（0）；
}
}
}
类生成器实现了Runnable{
向量sQ=新向量（）；
整数大小；
公共制作人（矢量平方，整数大小）{
这个.sQ=sQ；
这个。大小=大小；
}
@凌驾
公开募捐{
对于（int i=0；i<12；++i）{
试一试{
生产（一）；
}捕捉（中断异常e）{
e、 printStackTrace（）；
}
}
}
私有void product（inti）抛出InterruptedException{
同步（sQ）{
while（sQ.size（）==大小）{
System.out.println（“队列已满且”
+Thread.currentThread（）.getName（）+“必须等待。”
+尺寸为：“+sQ.size（））；
sQ.wait（）；
}
sQ.add（i）；
sQ.notify（）；
}
}
}

建议的方法通常是在需要终止的线程上设置布尔标志（

finished

或类似），然后在（！finished）时循环

。（请注意，该标志通常需要是
volatile
，以便线程看到更改。）如果预期线程将阻塞，则可以
中断（）
它以重新启动其等待循环

不过，您所采取的总体方法似乎已经过时。
BlockingQueue
实现是专门为简化生产者-消费者实现而设计的，许多这样的问题可以通过使用
执行器
来更有效地处理，并在任务进入时向其发射任务，而不是手动排队和轮询。
推荐的方法通常是在需要终止的线程上设置布尔标志（
完成
或类似），然后在执行时循环
（！finished）
（请注意，标记通常需要是
volatile
，以便线程看到更改。）如果预期线程将阻塞，则可以
中断（）
它以重新启动其等待循环

不过，您所采用的总体方法似乎已经过时。
阻塞队列
实现是专门为简化生产者-消费者实施而设计的，通过使用
执行器
并在任务进入时向其发射任务，而不是手动将任务排队，可以更有效地处理许多此类问题nd轮询。
使用倒计时锁存器。这允许您在一个线程中等待它被降低，并从另一个线程中实际降低它。它是线程安全的，专为此用例而设计

如果要使用布尔值，如其中一个命令中所建议的，请使用原子布尔值

一般来说，避免使用诸如synchronized或volatile之类的语言原语，而是使用java.concurrent包提供的更高级别的构造。如果您打算使用低级别，则需要对语义有一个明确的理解

如果您想重复使用而不是重新发明，您可能希望使用my concurrent processing iterable：

您只需对输入进行foreach操作，它就可以同时生成具有所需线程数的输出。
使用CountdownLatch。这允许您等待它在一个线程中降低，并实际从另一个线程中降低。它是线程安全的，专为这种用例而设计

如果要使用布尔值，如其中一个命令中所建议的，请使用原子布尔值

一般来说，避免使用诸如synchronized或volatile之类的语言原语，而是使用java.concurrent包提供的更高级别的构造。如果您打算使用低级别，则需要对语义有一个明确的理解

如果您想重复使用而不是重新发明，您可能希望使用my concurrent processing iterable：

您只需在输入上foreach，它就会并发地生成o