CODEWITHSUNDEEP
javaspringspring-boot
Jerry Zhou
Jerry Zhou

Reputation: 229

What would happen to the threads managed by ExecutorService when tomcat shutting down?

I have an web app(with Spring/Spring boot) running on tomcat 7.There are some ExecutorService defined like:

    public static final ExecutorService TEST_SERVICE = new ThreadPoolExecutor(10, 100, 60L,
        TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(1000), new ThreadPoolExecutor.CallerRunsPolicy());

The tasks are important and must complete properly. I catch the exceptions and save them to db for retry, like this:

try {
        ThreadPoolHolder.TEST_SERVICE.submit(new Runnable() {
            @Override
            public void run() {
                try {
                    boolean isSuccess = false;
                    int tryCount = 0;
                    while (++tryCount < CAS_COUNT_LIMIT) {
                        isSuccess = doWork(param);
                        if (isSuccess) {
                            break;
                        }
                        Thread.sleep(1000);
                    }
                    if (!isSuccess) {
                        saveFail(param);
                    }
                } catch (Exception e) {
                    log.error("test error! param : {}", param, e);
                    saveFail(param);
                }
            }
        });
    } catch (Exception e) {
        log.error("test error! param:{}", param, e);
        saveFail(param);
    }

So, when tomcat shutting down, what will happen to the threads of the pool(running or waiting in the queue)? how to make sure that all the tasks either completed properly before shutdown or saved to db for retry?

Upvotes: 1

Views: 1367

Answers (2)

Klaus Groenbaek
Klaus Groenbaek

Reputation: 5045

Tomcat has built in Thread Leak detection, so you should get an error when the application is undeployed. As a developer it is your responsibility to link any object you create to the web applications lifecycle, this means You should never ever have static state which are not constants

If you are using Spring Boot, your Spring context is already linked to the applications lifecycle, so the best way is to create you executor as a Spring bean, and let Spring shut it down when the application stops. Here is an example you can put in any @Configuration class.

@Bean(destroyMethod = "shutdownNow", name = "MyExecutorService")
public ThreadPoolExecutor executor() {
    ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(10, 100, 60L,
            TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(1000), 
            new ThreadPoolExecutor.CallerRunsPolicy());
    return threadPoolExecutor;
}

As you can see the @Bean annotation allows you to specify a destroy method which will be executed when the Spring context is closed. In addition I have added the name property, this is because Spring typically creates a number of ExecutorServices for stuff like async web processing. When you need to use the executor, just Autowire it as any other spring bean.

@Autowired
@Qualifier(value = "MyExecutorService")
ThreadPoolExecutor executor;

Remember static is EVIL, you should only use static for constants, and potentially immutable obbjects.

EDIT

If you need to block the Tomcats shutdown procedure until the tasks have been processed, you need to wrap the Executor in a Component for more control, like this.

@Component
public class ExecutorWrapper implements DisposableBean {

    private final ThreadPoolExecutor threadPoolExecutor;

    public ExecutorWrapper() {
        threadPoolExecutor = new ThreadPoolExecutor(10, 100, 60L,
                TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(1000), new ThreadPoolExecutor.CallerRunsPolicy());
    }

    public <T> Future<T> submit(Callable<T> task) {
        return threadPoolExecutor.submit(task);
    }

    public void submit(Runnable runnable) {
        threadPoolExecutor.submit(runnable);
    }

    @Override
    public void destroy() throws Exception {
        threadPoolExecutor.shutdown();
        boolean terminated = threadPoolExecutor.awaitTermination(1, TimeUnit.MINUTES);
        if (!terminated) {
            List<Runnable> runnables = threadPoolExecutor.shutdownNow();
            // log the runnables that were not executed
        }
    }
}

With this code you call shutdown first so no new tasks can be submitted, then wait some time for the executor finish the current task and queue. If it does not finish in time you call shutdownNow to interrupt the running task, and get the list of unprocessed tasks.

Note: DisposableBean does the trick, but the best solution is actually to implement the SmartLifecycle interface. You have to implement a few more methods, but you get greater control, because no threads are started until all bean have been instantiated and the entire bean hierarchy is wired together, it even allows you to specify in which orders components should be started.

Upvotes: 1

Evgeniy Dorofeev
Evgeniy Dorofeev

Reputation: 136092

Tomcat as any Java application will not end untill all non-daeon threads will end. ThreadPoolExecutor in above example uses default thread factory and will create non-daemon threads.

Upvotes: 1

Related Questions