Java 为什么所有生产者线程都退出而消费者线程都退出

我正在运行以下代码，我有一个问题：

当使用者线程全部退出时，为什么所有生产者线程也退出

代码如下：

public class NumbersConsumer implements Runnable {
    private final BlockingQueue<Integer> queue;
    private final int poisonPill;

    NumbersConsumer(BlockingQueue<Integer> queue, int poisonPill) {
        this.queue = queue;
        this.poisonPill = poisonPill;
    }

    public void run() {
        try {
            while (true) {
                Integer number = queue.take();
                if (number.equals(poisonPill)) {
                    return;
                }
                String result = number.toString();
                System.out.println(Thread.currentThread().getName() + " result: " + result);
            }
        } catch (InterruptedException e) {

            System.out.println(e.getStackTrace());
            Thread.currentThread().interrupt();
        }
    }
}

公共类NumbersConsumer实现可运行{
私有最终阻塞队列；
私家药丸；
NumbersConsumer（阻塞队列队列，整数）{
this.queue=队列；
这个。毒丸=毒丸；
}
公开募捐{
试一试{
while（true）{
整数=queue.take（）；
如果（数字等于（毒丸））{
返回；
}
字符串结果=number.toString（）；
System.out.println（Thread.currentThread（）.getName（）+“result:”+result）；
}
}捕捉（中断异常e）{
System.out.println（e.getStackTrace（））；
Thread.currentThread（）.interrupt（）；
}
}
}

制作人：

public class NumbersProducer implements Runnable {  
    private final BlockingQueue<Integer> numbersQueue;
    private final int poisonPill;
    private final int poisonPillPerProducer;

    NumbersProducer(BlockingQueue<Integer> numbersQueue, int poisonPill, int poisonPillPerProducer) {
        this.numbersQueue = numbersQueue;
        this.poisonPill = poisonPill;
        this.poisonPillPerProducer = poisonPillPerProducer;
    }

    public void run() {
        try {
            generateNumbers();
        } catch (InterruptedException e) {

            System.out.println(e.getStackTrace());
            Thread.currentThread()
                .interrupt();
        }
    }

    private void generateNumbers() throws InterruptedException {
        for (int i = 0; i < 100; i++) {
            numbersQueue.put(ThreadLocalRandom.current()
                .nextInt(100));
        }
        for (int j = 0; j < poisonPillPerProducer; j++) {
            numbersQueue.put(poisonPill);
        }
    }
}

公共类NumbersProducer实现可运行{
专用最终封锁队列编号队列；
私家药丸；
私人最终生产商；
NumbersProducer（封锁队列numbersQueue、int-Townpill、int-TownpillPerProducer）{
this.numbersque=numbersque；
这个。毒丸=毒丸；
this.townpillperproducer=townpillperproducer；
}
公开募捐{
试一试{
generateNumbers（）；
}捕捉（中断异常e）{
System.out.println（e.getStackTrace（））；
Thread.currentThread（）
.中断（）；
}
}
私有void generateNumbers（）引发InterruptedException{
对于（int i=0；i<100；i++）{
numbersQueue.put（ThreadLocalRandom.current（）
.nextInt（100））；
}
for（int j=0；j

测试人员：

public class BlockingQueueUsage {
    public static void main(String[] args) {
        int BOUND = 10;
        int N_PRODUCERS = 4;
        int N_CONSUMERS = Runtime.getRuntime().availableProcessors();
        int poisonPill = Integer.MAX_VALUE;

        int poisonPillPerProducer =N_CONSUMERS / N_PRODUCERS ;

        System.out.printf("poisonPillPerProducer:%s,N_CONSUMERS:%s %n",poisonPillPerProducer,N_CONSUMERS);

        BlockingQueue<Integer> queue = new LinkedBlockingQueue<>(BOUND);

        for (int i = 0; i < N_PRODUCERS; i++) {    
            new Thread(new NumbersProducer(queue, poisonPill, poisonPillPerProducer),"Producer"+i).start();    
        }

        for (int j = 0; j < N_CONSUMERS; j++) {    
            new Thread(new NumbersConsumer(queue, poisonPill),"comsumer"+j).start();
        }
    }
}

公共类阻止队列使用{
公共静态void main（字符串[]args）{
int-BOUND=10；
int N_=4；
int N_CONSUMERS=Runtime.getRuntime（）.availableProcessors（）；
int=Integer.MAX_值；
int=N个消费者/N个生产者；
System.out.printf（“毒药生产者：%s，N个消费者：%s%N”，毒药生产者，N个消费者）；
BlockingQueue=新的LinkedBlockingQueue（绑定）；
对于（int i=0；i

很简单：您的制作人缺少一个循环

这些产品除了生产一些数字之外什么也不做，而那些毒丸将终结消费者

另一方面，消费者将永远消费。。。直到那颗药丸进来

换句话说：你的制作人“结束”，因为他们不是为了生存而设计的