Understanding Spring @Async and Custom Thread Pools

Spring provides the @Async annotation (available since Spring 3) to execute methods asynchronously; the caller returns immediately while the actual work is submitted to a TaskExecutor thread pool.

Application Scenarios

Synchronous

All steps are executed sequentially, and the caller waits for each step to finish before proceeding.

Asynchronous

The caller issues the method call and continues without waiting for its completion, allowing subsequent steps to run in parallel.

Spring‑Provided Executors

SimpleAsyncTaskExecutor – creates a new thread for each task (not a true pool).

SyncTaskExecutor – performs tasks synchronously.

ConcurrentTaskExecutor – adapter, rarely needed.

SimpleThreadPoolTaskExecutor – shared by Quartz and non‑Quartz code.

ThreadPoolTaskExecutor – most common, wraps java.util.concurrent.ThreadPoolExecutor.

Typical @Async method signatures include void methods, methods with parameters, and methods returning Future or CompletableFuture.

Default @Async Thread Pool

The default executor is SimpleAsyncTaskExecutor, which creates a new thread per task and can cause memory exhaustion. It supports a concurrencyLimit property to enable simple throttling.

Problems with the Default Pool

Using Executors factories (e.g., newFixedThreadPool, newCachedThreadPool) may lead to unbounded queues or thread counts, risking OOM errors. Alibaba’s Java development guidelines recommend configuring a ThreadPoolExecutor directly.

Custom Thread Pool Configuration

To replace the default pool, define a bean named TaskExecutor or implement one of the following approaches:

Implement AsyncConfigurer and override getAsyncExecutor().

Extend AsyncConfigurerSupport.

Provide a custom TaskExecutor bean.

Example of a custom executor chain (shown in source):

Executor.class:ThreadPoolExecutorAdapter->ThreadPoolExecutor->AbstractExecutorService->ExecutorService->Executor

And the corresponding TaskExecutor hierarchy:

TaskExecutor.class:ThreadPoolTaskExecutor->SchedulingTaskExecutor->AsyncTaskExecutor->TaskExecutor

When using CompletableFuture, the @Async annotation is not required; the framework’s thread pool can still be leveraged.

Sample CompletableFuture usage from the article:

stage.thenApply(x -> square(x)).thenAccept(x -> System.out.print(x)).thenRun(() -> System.out.println())

By configuring a custom thread pool, developers gain fine‑grained control over pool size, rejection policies, and exception handling, leading to more stable and efficient asynchronous processing in Spring applications.