Mastering Spring Boot Thread Pools: From Default Config to Custom Solutions

Spring Boot Default Thread Pool

Spring Boot automatically creates a ThreadPoolTaskExecutor through TaskExecutionAutoConfiguration. The configuration defines a TaskExecutorBuilder bean that sets properties such as corePoolSize, maxPoolSize, queueCapacity, keepAlive, threadNamePrefix, customizers and a task decorator, and then lazily builds the executor bean.

@ConditionalOnClass(ThreadPoolTaskExecutor.class)
@Configuration
@EnableConfigurationProperties(TaskExecutionProperties.class)
public class TaskExecutionAutoConfiguration {
    @Bean
    @ConditionalOnMissingBean
    public TaskExecutorBuilder taskExecutorBuilder() {
        TaskExecutionProperties.Pool pool = this.properties.getPool();
        TaskExecutorBuilder builder = new TaskExecutorBuilder();
        builder.queueCapacity(pool.getQueueCapacity())
               .corePoolSize(pool.getCoreSize())
               .maxPoolSize(pool.getMaxSize())
               .allowCoreThreadTimeOut(pool.isAllowCoreThreadTimeout())
               .keepAlive(pool.getKeepAlive())
               .threadNamePrefix(this.properties.getThreadNamePrefix())
               .customizers(this.taskExecutorCustomizers)
               .taskDecorator(this.taskDecorator.getIfUnique());
        return builder;
    }

    @Lazy
    @Bean(name = {APPLICATION_TASK_EXECUTOR_BEAN_NAME, AsyncAnnotationBeanPostProcessor.DEFAULT_TASK_EXECUTOR_BEAN_NAME})
    @ConditionalOnMissingBean(Executor.class)
    public ThreadPoolTaskExecutor applicationTaskExecutor(TaskExecutorBuilder builder) {
        return builder.build();
    }
}

Purpose

Provides an async TaskExecutor for methods annotated with @Async.

Provides a scheduler ( ThreadPoolTaskScheduler) for @Scheduled tasks.

Both components can be tuned via application.properties or application.yml under the spring.task.execution and spring.task.scheduling namespaces.

Default Parameters (Spring Boot 2.1+)

Core pool size: 8 Maximum pool size: Integer.MAX_VALUE (unlimited)

Queue capacity: Integer.MAX_VALUE (unlimited)

Keep‑alive seconds: 60 Rejected execution handler: AbortPolicy These defaults can be overridden in the configuration files.

@ConfigurationProperties("spring.task.execution")
public class TaskExecutionProperties {
    private String threadNamePrefix = "task-";
    public static class Pool {
        private int queueCapacity = Integer.MAX_VALUE;
        private int coreSize = 8;
        private int maxSize = Integer.MAX_VALUE;
    }
}

How @Async Resolves the Executor

The method AsyncExecutionAspectSupport#determineAsyncExecutor follows these steps:

Check a cache for a previously resolved executor.

If the @Async annotation specifies a qualifier, look up a bean with that name.

If no qualifier is present, use the default executor; if the default does not exist, create it lazily.

protected AsyncTaskExecutor determineAsyncExecutor(Method method) {
    AsyncTaskExecutor executor = this.executors.get(method);
    if (executor == null) {
        Executor targetExecutor;
        String qualifier = getExecutorQualifier(method);
        if (StringUtils.hasLength(qualifier)) {
            targetExecutor = findQualifiedExecutor(this.beanFactory, qualifier);
        } else {
            targetExecutor = this.defaultExecutor;
            if (targetExecutor == null) {
                synchronized (this.executors) {
                    if (this.defaultExecutor == null) {
                        this.defaultExecutor = getDefaultExecutor(this.beanFactory);
                    }
                    targetExecutor = this.defaultExecutor;
                }
            }
        }
        if (targetExecutor == null) {
            return null;
        }
        executor = (targetExecutor instanceof AsyncListenableTaskExecutor) ?
                (AsyncListenableTaskExecutor) targetExecutor :
                new TaskExecutorAdapter(targetExecutor);
        this.executors.put(method, executor);
    }
    return executor;
}

Before Spring Boot 2.1 the fallback executor is SimpleAsyncTaskExecutor.

protected Executor getDefaultExecutor(@Nullable BeanFactory beanFactory) {
    if (beanFactory != null) {
        try {
            return beanFactory.getBean(TaskExecutor.class);
        } catch (NoUniqueBeanDefinitionException ex) {
            return beanFactory.getBean("taskExecutor", Executor.class);
        } catch (NoSuchBeanDefinitionException ex) {
            return beanFactory.getBean("taskExecutor", Executor.class);
        }
    }
    return null;
}

Practical Example (Post‑2.1)

@Service
public class SyncService {
    @Async
    public void testAsync1() {
        System.out.println(Thread.currentThread().getName());
        ThreadUtil.sleep(10, TimeUnit.DAYS);
    }
    @Async
    public void testAsync2() {
        System.out.println(Thread.currentThread().getName());
        ThreadUtil.sleep(10, TimeUnit.DAYS);
    }
}

@RestController
public class TestController {
    @Autowired
    SyncService syncService;

    @RequestMapping("/testSync")
    public void testSync() {
        syncService.testAsync1();
        syncService.testAsync2();
    }
}

Enable async processing with @EnableAsync on the main application class. The console prints thread names such as task-1 and task-2, confirming that the default ThreadPoolTaskExecutor is used.

@Async Caveats

Add @EnableAsync to the startup class.

Annotated methods must be public and non‑static.

The call must come from another bean; self‑invocation bypasses the proxy and does not trigger async execution.

Injecting the Executor Directly (Post‑2.1)

@RestController
public class TestController {
    @Resource
    ThreadPoolTaskExecutor taskExecutor; // works after 2.1

    @RequestMapping("/testSync")
    public void testSync() {
        ThreadPoolExecutor executor = taskExecutor.getThreadPoolExecutor();
    }
}

Before Spring Boot 2.1

@Async Uses SimpleAsyncTaskExecutor

@Service
public class SyncService {
    @Async
    public void testAsync1() { /* ... */ }
    @Async
    public void testAsync2() { /* ... */ }
}

@RestController
public class TestController {
    @Autowired
    SyncService syncService;

    @RequestMapping("/testSync")
    public void testSync() {
        syncService.testAsync1();
        syncService.testAsync2();
    }
}

Running the controller prints thread names like SimpleAsyncTaskExecutor-1 and SimpleAsyncTaskExecutor-2.

Direct Injection Fails

Attempting to inject ThreadPoolTaskExecutor before 2.1 results in a startup error because no bean of that type exists.

Custom Thread Pool Definition (Pre‑2.1)

@Configuration
public class ThreadPoolConfiguration {
    @Bean("taskExecutor")
    public ThreadPoolTaskExecutor taskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(50);
        executor.setQueueCapacity(200);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("myExecutor--");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.setAwaitTerminationSeconds(60);
        executor.setRejectedExecutionHandler(new ThreadPoolExecutor.CallerRunsPolicy());
        executor.initialize();
        return executor;
    }
}

After defining this bean, @Async uses the custom pool instead of SimpleAsyncTaskExecutor.

Production Suitability

The default executor’s unlimited maximum threads and queue capacity can cause serious problems in production:

Resource exhaustion: unlimited threads may quickly consume CPU and memory.

Excessive context switching degrades responsiveness.

Unbounded queue growth can lead to OutOfMemoryError. AbortPolicy rejects tasks abruptly without fallback.

Lack of workload‑specific tuning.

SimpleAsyncTaskExecutor Limitations

It creates a new thread for each task, does not reuse threads, has no queue, and therefore is unsuitable for high‑concurrency or long‑running services.

Conclusion: While Spring Boot’s auto‑configured ThreadPoolTaskExecutor simplifies development, its default parameters should be tuned or replaced with a custom pool for production environments.