Why does the execute() method of ExecutorService returned from Executors utility class could not terminate naturally

Question

As we know, the java.util.concurrent.Executors contains many methods such as

• newCachedThreadPool

• newFixedThreadPool

• newScheduledThreadPool

• newSingleThreadExecutor

• newSingleThreadScheduledExecutor

  They return ExecutorService, which contains the execute(Runnable task) method. However, when calling the execute(Runnable task) of ExecutorService returned from the aforementioned factory methods, it could only terminate by calling shutdown() or shutdownNow()

For instance, if we add the following code to the main method,

ExecutorService e = Executors.newSingleThreadExecutor();
e.execute(() -> system.out.println("test")); 

the calling the the main program will never terminate as the shutdown() or shutdownNow() is not called. So a program containing the following snippet in main will terminate

ExecutorService e = Executors.newSingleThreadExecutor();
e.execute(() -> system.out.println("test"));
e.shutdown();

However, some subclasses of ExecutorService such as the one returned by calling Executors.newWorkStealingPool or the ForkJoinPool can terminate without calling shutdown() or shutdownNow()

So my QUESTION is: why does the execute() of the ExecutorService returned from the aforementioned factory methods starting with "new" not terminate without calling shutdown() or shutdownNow() from the design point of view?

Answer 1

Rui, the answer for why your example hangs is simple. By default, the threads in the ExecutorService are non-daemon threads and a Java program won't exit as long as there are non-daemon threads running. If you don't want this behavior all you need to do is define a ThreadFactory that creates daemon threads, like this:

public class Test {
    static ThreadFactory mThreadFactory = new ThreadFactory() {
        public Thread newThread(Runnable r) {
            Thread t = new Thread(r);
            t.setDaemon(true);
            return t;
        }
    };

    public static void main(String[] args) {
        ExecutorService e = Executors.newSingleThreadExecutor(mThreadFactory);
        e.execute(new Runnable() { public void run() { System.out.println("test"); } });
    }
}

Answer 2

Briefly about java threads: there are two types of threads - daemon and non-daemon. The program terminates when all of its non-daemon threads have finished execution. Daemon threads can only run as long the program is running and do not block termination, e.g. garbage collector. When a java program starts all of its threads except the main thread are daemon.

newSingleThreadExecutor() and its defaultThreadFactory() create non-daemon threads. Which kinda makes sense - you're creating a pool of threads that wait for work, it should be your explicit intention to shut it down.

ForkJoinPool, on the other hand, abstracts you from the underlying thread pool. So it can use daemon threads, as it is generally your intention to wait for task execution anyways.