为什么执行器不关机？

Question

I am working on the Producer Consumer pattern using Executors with a Blocking Queue.I am not able to understand why this pool does not shutdown and the main thread terminate?

Idea is I have just one producer and multiple consumers(100)

I have a poison pill item (-1) whcih when consumed should trigger a shutdown of the pool.

Everything seems to be working fine, but the program never terminates.

Here is my code:

Producer class:

class Producer implements Runnable {

        protected BlockingQueue queue = null;

        public Producer(BlockingQueue queue) {
            this.queue = queue;
        }

        public void run() {
            try {

                for (int i = 0; i < 30000; i++) {
                    queue.put(i);
                    // System.out.println("Producer ID "+Thread.currentThread().getId()+" is adding task : "+i);
                }
                // poison pill
                // System.out.println("Poison number added! "+Thread.currentThread().getId());
                queue.put(-1);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }

Consumer Class:

 class Consumer implements Runnable {

        protected BlockingQueue queue = null;
        ConcurrentHashMap<Integer, Integer> hashmap;

        public Consumer(BlockingQueue queue,
                ConcurrentHashMap<Integer, Integer> hashmap) {
            this.queue = queue;
            this.hashmap = hashmap;
        }

        public void run() {
            try {

                //while (ExecutorTest.isRunning) {
                    Integer i = (Integer) queue.take();
                    System.out.println("Consumer " + Thread.currentThread().getId()
                            + ": taking Task : " + i);
                    if (i == -1) {
                        //queue.put(i);
                        ExecutorTest.isRunning = false;
                        // System.out.println("Setting isRunning to false :  "+Thread.currentThread().getId());
                        //return;
                    }
                    hashmap.put(i, i);
                //}

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

Main Program:

public class ExecutorTest {

static BlockingQueue<Integer> queue = new LinkedBlockingQueue<Integer>();
static ConcurrentHashMap<Integer, Integer> hashmap = new ConcurrentHashMap<Integer, Integer>();
static volatile boolean isRunning = true;

public static void main(String[] args) {
    Producer producer = new Producer(queue);
    Consumer consumer = new Consumer(queue, hashmap);

    new Thread(producer).start();
    ExecutorService executorService = Executors.newFixedThreadPool(100);

    // wait for the threads to finish
    while (isRunning) {
        executorService.execute(consumer);
    };

    try {
        executorService.shutdown();
        System.out.println("SHUT DOWN THREAD POOL");
        while(!executorService.isShutdown()){

        }

        executorService.awaitTermination(1, TimeUnit.SECONDS);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }


    System.out.println("HASHMAP SIZE : " + hashmap.size());

    try {
        queue.put(100);
    } catch (InterruptedException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
}

public static void printHashMap() {
    for (Map.Entry<Integer, Integer> map : hashmap.entrySet()) {
        System.out.println("Entry " + map.getKey() + ":" + map.getValue());
    }
}

}

Answer 1

You are spawning potentially a lot of consumer here :

 while (isRunning) {
    executorService.execute(consumer);
 };

these consumers will block on queue.take and never finish. Only the first one able to take -1 will be closed.

Try shutdownNow() , but to be honest, i don't understand the purpose of your while loops, you shoudn't do that.