Block Java application from exiting until ThreadPool is empty

Question

I've got an ExecutorService sitting inside a singleton class which receives tasks from many different classes. On application shutdown, I need to wait for the pool to be empty before I allow the application to exit.

private static NotificationService instance = null;

private ExecutorService executorService = Executors.newFixedThreadPool(25);

public static synchronized NotificationService getInstance() {
    if (instance == null) {
        instance = new NotificationService(true);
    }
    return instance;
}

While using this NotificationService, it frequently happens that I restart the application and the executorService hasn't finished processing all the notifications.

For Testing, I can manually shutdown the executorService and wait until all tasks are completed.

public static boolean canExit() throws InterruptedException {
    NotificationService service = getInstance();
    service.executorService.shutdown();
    service.executorService.awaitTermination(30, TimeUnit.SECONDS);
    return service.executorService.isTerminated();
}

Is it reliable and safe to override the finalize method and wait there until the pool is empty? From what I've read, finalize is not always called, especially not when using a singleton class.

@Override
protected void finalize() throws Throwable {
    while (!canExit()){
        Thread.sleep(100);
    }
    super.finalize();
}

This code is included in a library that will be included in another application, so there's no main method where I can wait until the pool is empty, unless I force the person using it to do so which is not great.

What is the correct way to stall the application (for a reasonable amount of time) from terminating until the pool is empty?

Answer 1

You can use addShutdownHook to catch the process termination event and wait for the pool there.

example:

 Runtime.getRuntime().addShutdownHook(new Thread() {
      public void run() {
        NotificationService service = getInstance();
        service.executorService.shutdown();
        service.executorService.awaitTermination(30, TimeUnit.SECONDS);
      }
    });

Answer 2

Answered here: Java Finalize method call when close the application Finalizers do not run on exit by default and the functionality to do this is deprecated.

One common advice is to use the Runtime.addShutdownHook but be aware of the following line of documentation:

Shutdown hooks should also finish their work quickly. When a program invokes exit the expectation is that the virtual machine will promptly shut down and exit. When the virtual machine is terminated due to user logoff or system shutdown the underlying operating system may only allow a fixed amount of time in which to shut down and exit. It is therefore inadvisable to attempt any user interaction or to perform a long-running computation in a shutdown hook.

In all honesty the best way to ensure everything gets properly cleaned up is to have your own application lifecycle which you can end before you even ask the VM to exit.

Answer 3

Don't use blocking shutdown hooks or anything similar in a library. You never know how the library is meant to be used. So it should always be up to the code that is using your library to take sensible actions on shut down.

Of course, you have to provide the necessary API for that, e.g. by adding lifecycle-methods to your class:

public class NotificationService {
    ...

    public void start() {
        ...
    }

    /**
     * Stops this notification service and waits until
     * all notifications have been processed, or a timeout occurs.
     * @return the list of unprocessed notification (in case of a timeout),
               or an empty list.
     */
    public List<Notification> stop(long timeout, TimeUnit unit) {
        service.shutdown();
        if (!service.awaitTermination(timeout, unit)) {
            List<Runnable> tasks = service.shutdownNow();
            return extractNotification(tasks);
        }
        return Collections.emptyList();
    }

    private List<Notification> extractNotification(List<Runnable> tasks) {
        ...
    }
}

Then, the application code can take the required actions to handle your service, e.g.:

public static void main(String[] args) {
    NotificationService service = new NotificationService(...);
    service.start();
    try {
        // use service here
    } finally {
        List<Notification> pending = service.stop(30, TimeUnit.SECONDS);
        if (!pending.isEmpty()) {
            // timeout occured => handle pending notifications
        }
    }
}

Btw.: Avoid using singletons, if feasible.