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

Question

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

我尝试了以下代码，但 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();
            }

        }
    }

Answer 1

推荐的方法通常是在需要终止的线程上设置一个 boolean 标志(finished 或类似的)，然后循环 while(!finished)。 (请注意，该标志通常需要是 volatile ，以便线程能够看到更改。)如果线程预计会阻塞，那么您可以interrupt()它来重新启动其等待循环。

不过，您所采取的总体方法似乎已经过时了。 BlockingQueue 实现是专门为简化生产者-消费者实现而设计的，通过使用 Executor 并在任务进入时向其发送任务，可以更有效地处理许多此类问题而不是手动排队和轮询。