`@Scheduled` tasks running in `SimpleAsyncTaskScheduler` are interrupted immediately on context close

[kzander91]

Spring 6.2.9

When Spring Boot auto-configures a SimpleAsyncTaskScheduler (with virtual threads enabled) to be used for running @Scheduled tasks, closing the application context will immediately interrupt the threads executing those tasks.
I was expecting the taskTerminationTimeout to be respected before hard-killing running tasks.

The offending code is here (calling Future.cancel with true):

spring-framework/spring-context/src/main/java/org/springframework/scheduling/concurrent/SimpleAsyncTaskScheduler.java

Lines 397 to 401 in 09a5ca3

	for (Runnable remainingTask : this.fixedDelayExecutor.shutdownNow()) {
	if (remainingTask instanceof Future<?> future) {
	future.cancel(true);
	}
	}

and here (explicitly calling Thread.interrupt(), not allowing graceful completion):

spring-framework/spring-core/src/main/java/org/springframework/core/task/SimpleAsyncTaskExecutor.java

Lines 362 to 380 in 09a5ca3

	public void close() {
	if (this.active) {
	this.active = false;
	Set<Thread> threads = this.activeThreads;
	if (threads != null) {
	threads.forEach(Thread::interrupt);
	synchronized (threads) {
	try {
	if (!threads.isEmpty()) {
	threads.wait(this.taskTerminationTimeout);
	}
	}
	catch (InterruptedException ex) {
	Thread.currentThread().interrupt();
	}
	}
	}
	}
	}

Note how running threads are interrupted immediately, and then we wait for them to finish their work.

A similar issue was fixed in the past (#31019), but the fix made there doesn't help if the underlying TaskExecutor is itself also interrupting threads.

The end result is that scheduled tasks currently waiting for the database or some other service will be interrupted and fail immediately, thus preventing graceful shutdown and making the taskTerminationTimeout almost useless.

[jhoeller]

SimpleAsyncTaskScheduler is trying to stop all triggers and fixed-delay tasks in its stop implementation within Spring's lifecycle management; is this being called in your scenario? Are you alternatively or additionally relying on taskTerminationTimeout there?

[kzander91]

@jhoeller No. I put breakpoints into close() and both stop methods: Only close() is being called during shutdown (during singleton destruction through DisposableBeanAdapter).

I stepped through DefaultLifecycleProcessor#doStop and found that the stop method is skipped because SimpleAsyncTaskScheduler#isRunning returns false. That method delegates to triggerLifecycle.isRunning() here:

spring-framework/spring-context/src/main/java/org/springframework/scheduling/concurrent/SimpleAsyncTaskScheduler.java

Lines 377 to 380 in 09a5ca3

	@Override
	public boolean isRunning() {
	return this.triggerLifecycle.isRunning();
	}

That in turn checks if the underlying ExecutorService is running:

spring-framework/spring-context/src/main/java/org/springframework/scheduling/concurrent/ExecutorLifecycleDelegate.java

Lines 101 to 104 in 09a5ca3

	@Override
	public boolean isRunning() {
	return (!this.paused && !this.executor.isTerminated());
	}

Which it isn't, because the ContextClosedEvent has already shut it down here:

spring-framework/spring-context/src/main/java/org/springframework/scheduling/concurrent/SimpleAsyncTaskScheduler.java

Lines 382 to 388 in 09a5ca3

	@Override
	public void onApplicationEvent(ContextClosedEvent event) {
	if (event.getApplicationContext() == this.applicationContext) {
	this.triggerExecutor.shutdown();
	this.fixedDelayExecutor.shutdown();
	}
	}

[jhoeller]

Thanks, that helps a lot. I guess we need to check this.fixedDelayLifecycle.isRunning() there as well since the trigger lifecycle usually ends quicker than the fixed-delay lifecycle. I'll try to bring this into SimpleAsyncTaskScheduler in a 6.2.10 snapshot ASAP.

[kzander91]

Note that even with stop being called, non-fixed-delay tasks (cron, fixed-rate) are still being interrupted.
I just tested this by skipping the executor shutdown in the debugger to ensure that isRunning() returns true...

[jhoeller]

Indeed, we still need to do something about the pro-active interruption in SimpleAsyncTaskExecutor.close() - either integrating that tracking into SimpleAsyncTaskScheduler.stop() or interrupting only after the taskTerminationTimeout has been exceeded. The latter would help plain SimpleAsyncTaskExecutor usage as well.

[github-actions]

Fixed via 67e88f3

[jhoeller]

This is available in the latest 6.2.10 snapshot now. Please give it an early try and let me know whether it works for you!