Custom thread pool configuration in Spring Boot - Step-by-Step Execution

Concept Flow - Custom thread pool configuration

Define ThreadPoolTaskExecutor Bean

↓

Set corePoolSize, maxPoolSize, queueCapacity

↓

Initialize ThreadPoolTaskExecutor

↓

Inject Executor in Service

↓

Submit Tasks to Executor

↓

Tasks run concurrently with configured threads

↓

Shutdown Executor on app stop

This flow shows how Spring Boot creates and uses a custom thread pool to run tasks concurrently with your specified settings.

Execution Sample

Spring Boot

  @Bean
  public ThreadPoolTaskExecutor taskExecutor() {
    ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
    executor.setCorePoolSize(2);
    executor.setMaxPoolSize(4);
    executor.setQueueCapacity(10);
    executor.initialize();
    return executor;
  }

Defines a thread pool with 2 core threads, max 4 threads, and a queue that holds 10 tasks waiting.

Execution Table

Step	Action	ThreadPool State	Task Submitted	Thread Used	Queue Size
1	Initialize ThreadPoolTaskExecutor	core=2, max=4, queue=empty	No	0	0
2	Submit Task 1	core=2, max=4, queue=empty	Yes	1	0
3	Submit Task 2	core=2, max=4, queue=empty	Yes	2	0
4	Submit Task 3	core=2, max=4, queue=1 task waiting	Yes	2	1
5	Submit Task 4	core=2, max=4, queue=2 tasks waiting	Yes	2	2
6	Submit Task 5	core=2, max=4, queue=3 tasks waiting	Yes	2	3
7	Submit Task 6	core=2, max=4, queue=4 tasks waiting	Yes	2	4
8	Submit Task 7	core=2, max=4, queue=5 tasks waiting	Yes	2	5
9	Submit Task 8	core=2, max=4, queue=6 tasks waiting	Yes	2	6
10	Submit Task 9	core=2, max=4, queue=7 tasks waiting	Yes	2	7
11	Submit Task 10	core=2, max=4, queue=8 tasks waiting	Yes	2	8
12	Submit Task 11	core=2, max=4, queue=9 tasks waiting	Yes	2	9
13	Submit Task 12	core=2, max=4, queue=10 tasks waiting (full)	Yes	2	10
14	Submit Task 13	core=2, max=4, queue=10 tasks waiting (full)	Yes	3	10
15	Submit Task 14	core=2, max=4, queue=10 tasks waiting (full)	Yes	4	10
16	Submit Task 15	Rejected - queue full and max threads reached	Yes	4	10

💡 Task 15 rejected because max threads (4) are busy and queue (capacity 10) is full.

Variable Tracker

Variable	Start	After Task 1	After Task 4	After Task 10	After Task 14	Final
Active Threads	0	1	2	2	4	4
Queue Size	0	0	2	8	10	10
Tasks Rejected	0	0	0	0	0	1

Key Moments - 3 Insights

Why does the thread pool start with 0 active threads but can run tasks immediately?

The pool creates threads lazily. It starts with 0 but creates up to corePoolSize (2) threads as tasks come in, shown in rows 2-3 of execution_table.

What happens when the queue is full and max threads are busy?

New tasks are rejected because no threads or queue space are available, as seen in step 16 of execution_table.

Why does the queue start filling only after 2 tasks are submitted?

Because corePoolSize is 2, the pool creates threads up to 2 before queuing tasks, so queue fills starting from task 3 (row 4).

Visual Quiz - 3 Questions

Look at the execution_table, how many threads are active after submitting Task 3?

A 4

B 2

C 3

D 1

💡 Hint

Check the 'Thread Used' column at Step 4 in execution_table.

At which step does the queue first start holding tasks?

A Step 4

B Step 6

C Step 2

D Step 10

💡 Hint

Look at the 'Queue Size' column in execution_table to find when it changes from 0.

If maxPoolSize was increased to 6, what would happen at Step 16?

A Queue size would increase beyond 10

B Task 15 would still be rejected

C Task 15 would be accepted and run immediately

D Core pool size would increase automatically

💡 Hint

Consider that more threads can be created up to maxPoolSize before rejecting tasks.

Concept Snapshot

Define a ThreadPoolTaskExecutor bean in Spring Boot.
Set corePoolSize, maxPoolSize, and queueCapacity.
Core threads run tasks immediately.
Extra tasks queue until full.
Max threads handle overflow.
Tasks rejected if queue and threads full.

Full Transcript

This visual execution shows how to configure a custom thread pool in Spring Boot using ThreadPoolTaskExecutor. The pool starts with zero threads and creates up to corePoolSize threads as tasks arrive. When core threads are busy, new tasks queue up to the queueCapacity. If the queue fills and maxPoolSize threads are busy, new tasks are rejected. The execution table traces each task submission, thread usage, and queue size. Key moments clarify lazy thread creation, queue filling, and task rejection. The quiz tests understanding of thread counts, queue behavior, and configuration effects.