@EnableAsync annotation in Spring Boot - Step-by-Step Execution

Concept Flow - @EnableAsync annotation

Start Application

↓

Spring Boot Loads Context

↓

Detect @EnableAsync

↓

Create Async Executor

↓

Scan for @Async Methods

↓

Run @Async Methods in Separate Threads

↓

Main Thread Continues Without Waiting

↓

Async Task Completes Independently

This flow shows how Spring Boot detects @EnableAsync, sets up async support, and runs @Async methods on separate threads so the main thread doesn't wait.

Execution Sample

Spring Boot

@SpringBootApplication
@EnableAsync
public class App {
  @Async
  public void runTask() {
    // long task
  }
}

This code enables async support and runs runTask() asynchronously on a different thread.

Execution Table

Step	Action	Thread	State Before	State After	Output/Effect
1	Start Application	main	No context	Spring context created	Application starts
2	Detect @EnableAsync	main	No async support	Async support enabled	Async executor created
3	Call runTask()	main	No task running	Task submitted to executor	Main thread continues
4	Execute runTask()	async-thread-1	Task queued	Task running	Long task runs separately
5	runTask() completes	async-thread-1	Task running	Task done	Async task finished
6	Main thread continues	main	Task submitted	No change	Main thread not blocked
7	Application runs normally	main	Async task done	No change	App responsive

💡 Async task completes independently; main thread never waits for it.

Variable Tracker

Variable	Start	After Step 3	After Step 4	After Step 5	Final
Spring Context	Not created	Created	Created	Created	Created
Async Support	Disabled	Enabled	Enabled	Enabled	Enabled
runTask State	Not called	Submitted	Running	Completed	Completed
Main Thread State	Idle	Continues	Continues	Continues	Continues

Key Moments - 3 Insights

Why does the main thread not wait for the @Async method to finish?

Because @EnableAsync sets up a separate thread pool. The main thread submits the task and continues immediately, as shown in execution_table step 3 and 6.

What happens if @EnableAsync is missing but @Async is used?

The @Async annotation will be ignored and methods run synchronously on the main thread, so no separate thread is created. This is why detecting @EnableAsync is crucial (step 2).

How does Spring know which methods to run asynchronously?

Spring scans for methods annotated with @Async after enabling async support (step 4). Only those methods run on separate threads.

Visual Quiz - 3 Questions

Look at the execution table, at which step does the async task start running on a separate thread?

A Step 4

B Step 3

C Step 5

D Step 6

💡 Hint

Check the 'Thread' and 'State After' columns in step 4.

According to the variable tracker, what is the state of 'runTask State' after step 5?

A Submitted

B Completed

C Running

D Not called

💡 Hint

Look at the 'runTask State' row under 'After Step 5' in variable_tracker.

If @EnableAsync was removed, how would the main thread behave when calling runTask()?

A It would run runTask() asynchronously anyway

B It would throw an error

C It would run runTask() synchronously and wait

D It would skip runTask()

💡 Hint

Refer to key_moments about missing @EnableAsync and its effect.

Concept Snapshot

@EnableAsync enables Spring Boot to run methods annotated with @Async on separate threads.
Add @EnableAsync on a configuration class to activate async support.
Use @Async on methods to run them asynchronously.
Main thread submits async tasks and continues without waiting.
Spring manages thread pool and task execution automatically.

Full Transcript

When you add @EnableAsync to your Spring Boot application, it tells Spring to look for methods marked with @Async and run them on separate threads. This means your main program doesn't have to wait for these methods to finish. The flow starts when the application launches and Spring creates the context. It detects @EnableAsync and sets up an async executor. When you call an @Async method, the main thread submits the task to this executor and keeps running. Meanwhile, the async method runs on a different thread and finishes independently. If you forget @EnableAsync, your @Async methods will run like normal methods on the main thread, blocking it. This setup helps keep your app responsive by doing long tasks in the background.