Cancel WebAsyncManager thread on request timeout

Issue: SPR-15852

Author: rstoyanchev

spring-web/src/main/java/org/springframework/web/context/request/async/CallableInterceptorChain.java

@@ -18,6 +18,7 @@
 
 import java.util.List;
 import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
 
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
@@ -39,11 +40,19 @@ class CallableInterceptorChain {
 
 	private int preProcessIndex = -1;
 
+	private volatile Future<?> taskFuture;
+
 
 	public CallableInterceptorChain(List<CallableProcessingInterceptor> interceptors) {
 		this.interceptors = interceptors;
 	}
 
+
+	public void setTaskFuture(Future<?> taskFuture) {
+		this.taskFuture = taskFuture;
+	}
+
+
 	public void applyBeforeConcurrentHandling(NativeWebRequest request, Callable<?> task) throws Exception {
 		for (CallableProcessingInterceptor interceptor : this.interceptors) {
 			interceptor.beforeConcurrentHandling(request, task);
@@ -77,6 +86,7 @@ public Object applyPostProcess(NativeWebRequest request, Callable<?> task, Objec
 	}
 
 	public Object triggerAfterTimeout(NativeWebRequest request, Callable<?> task) {
+		cancelTask();
 		for (CallableProcessingInterceptor interceptor : this.interceptors) {
 			try {
 				Object result = interceptor.handleTimeout(request, task);
@@ -94,7 +104,20 @@ else if (result != CallableProcessingInterceptor.RESULT_NONE) {
 		return CallableProcessingInterceptor.RESULT_NONE;
 	}
 
+	private void cancelTask() {
+		Future<?> future = this.taskFuture;
+		if (future != null) {
+			try {
+				future.cancel(true);
+			}
+			catch (Throwable ex) {
+				// Ignore
+			}
+		}
+	}
+
 	public Object triggerAfterError(NativeWebRequest request, Callable<?> task, Throwable throwable) {
+		cancelTask();
 		for (CallableProcessingInterceptor interceptor : this.interceptors) {
 			try {
 				Object result = interceptor.handleError(request, task, throwable);

spring-web/src/main/java/org/springframework/web/context/request/async/WebAsyncManager.java

@@ -21,6 +21,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
 import java.util.concurrent.RejectedExecutionException;
 import javax.servlet.http.HttpServletRequest;
 
@@ -314,7 +315,7 @@ public void startCallableProcessing(final WebAsyncTask<?> webAsyncTask, Object..
 		interceptorChain.applyBeforeConcurrentHandling(this.asyncWebRequest, callable);
 		startAsyncProcessing(processingContext);
 		try {
-			this.taskExecutor.submit(() -> {
+			Future<?> future = this.taskExecutor.submit(() -> {
 				Object result = null;
 				try {
 					interceptorChain.applyPreProcess(this.asyncWebRequest, callable);
@@ -328,6 +329,7 @@ public void startCallableProcessing(final WebAsyncTask<?> webAsyncTask, Object..
 				}
 				setConcurrentResultAndDispatch(result);
 			});
+			interceptorChain.setTaskFuture(future);
 		}
 		catch (RejectedExecutionException ex) {
 			Object result = interceptorChain.applyPostProcess(this.asyncWebRequest, callable, ex);

spring-web/src/test/java/org/springframework/web/context/request/async/WebAsyncManagerTimeoutTests.java

@@ -17,6 +17,7 @@
 package org.springframework.web.context.request.async;
 
 import java.util.concurrent.Callable;
+import java.util.concurrent.Future;
 import javax.servlet.AsyncEvent;
 
 import org.junit.Before;
@@ -30,9 +31,12 @@
 
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
+import static org.mockito.ArgumentMatchers.any;
 import static org.mockito.BDDMockito.given;
 import static org.mockito.BDDMockito.mock;
 import static org.mockito.BDDMockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
 import static org.springframework.web.context.request.async.CallableProcessingInterceptor.RESULT_NONE;
 
 /**
@@ -151,6 +155,27 @@ public void startCallableProcessingAfterTimeoutException() throws Exception {
 		verify(interceptor).beforeConcurrentHandling(this.asyncWebRequest, callable);
 	}
 
+	@SuppressWarnings("unchecked")
+	@Test
+	public void startCallableProcessingTimeoutAndCheckThreadInterrupted() throws Exception {
+
+		StubCallable callable = new StubCallable();
+		Future future = mock(Future.class);
+
+		AsyncTaskExecutor executor = mock(AsyncTaskExecutor.class);
+		when(executor.submit(any(Runnable.class))).thenReturn(future);
+
+		this.asyncManager.setTaskExecutor(executor);
+		this.asyncManager.startCallableProcessing(callable);
+
+		this.asyncWebRequest.onTimeout(ASYNC_EVENT);
+
+		assertTrue(this.asyncManager.hasConcurrentResult());
+
+		verify(future).cancel(true);
+		verifyNoMoreInteractions(future);
+	}
+
 	@Test
 	public void startDeferredResultProcessingTimeoutAndComplete() throws Exception {