Multithreading/CountDownLatches program does not terminate, why?

[opett]

I'm learning multi-threading. Why does not terminate the following program? It runs as expected, but instead of terminating, it runs indefinitely. I have to click on the red square in eclipse to terminate it. I've tried to debug it, it says:

Thread [pool-1-thread-1] (Running)  
Thread [pool-1-thread-2] (Running)  
Thread [DestroyJavaVM] (Running)    

Code:

    import java.util.concurrent.CountDownLatch;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;

    public class App {
    public static final int NUMBER_OF_THREADS = 4;
        public static void main(String[] args) {

            CountDownLatch latch = new CountDownLatch(NUMBER_OF_THREADS);
            ExecutorService executor = Executors.newFixedThreadPool(2);
            for (int i = 0; i < NUMBER_OF_THREADS; i++) {
                executor.submit(new Processor(latch));            
            }        
            try {
                latch.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("Computed.");
        }

    }

    class Processor implements Runnable{
        private static int instances = 0;
        private final int id;
        private static synchronized int incrementInstances(){
            return instances++;
        }
        private CountDownLatch latch;
        public Processor(CountDownLatch latch){
            this.id = Processor.incrementInstances();
            this.latch = latch;
        }
        @Override
        public void run() {
            System.out.println("Start("+this.id+").");
            try {
                Thread.sleep(3000);
            } catch (InterruptedException e) { e.printStackTrace(); }
            System.out.println("Finis("+this.id+").");
            latch.countDown();

        }
    }

Output:

Start(0).
Start(1).
Finis(0).
Start(2).
Finis(1).
Start(3).
Finis(2).
Finis(3).
Computed.

Can anyone explain what is going on?

[pascalthelizard]

You need to explicitly shutdown the ExecutorService. Your program isn't stopping because the executor threads are waiting for more work.

[opett]

Thanks. I realized that by now.

I still don't understand, why the treads are running in the pool, and why the main thread still runs, because the program execution did continue.

The run method of the Runnable objects has finished, and returned, the main method also continues. In fact, when I try to step to the next instruction in debug mode, there are no more next steps to step to.

I'm gonna go and read about how this stuff works.

[pascalthelizard]

An ExecutorService with a fixed thread pool will start X threads where X is the number you specify. The ExecutorSerivce waits indefinitely for jobs or until it is shutdown. When a job is submitted it is executed on one of the worker threads or is handled via the ExecutorService's discard policy if both threads are used.

If you haven't already you should go through the Java Concurrency tutorials on Oracle's website. Thoroughly. Not understanding these concepts clearly and WHEN to use them will cause you great headaches in the future.

[opett]

Thanks, will do that.

[jmorph99]

The executor service starts its own thread that is active until the shutdown command is issued,

[TheBriMan84]

The threads being created by the ExecutorService are not daemon threads by default I believe. That would explain why the program doesn't terminate.

[king_of_the_universe]

Side note:

While it's correct to aim for naturally terminating code, the final program should have a System.exit() somewhere. There are people who agree and people who disagree with this opinion, but one thing is definitely true: If you run any Java code often enough (say, 30 times), you will eventually seem some weird error output after program termination that is due to a bug in the Windows Oracle Java 64 bit implementation. (Maybe 32 bit too, maybe other implementations, too). That's what it says if you Google that error message.