Why async processing matters in Spring Boot - See It in Action

Why async processing matters

📖 Scenario: You are building a simple Spring Boot web service that handles user requests. Normally, the service processes each request one by one, which can cause delays when some tasks take longer. To improve user experience, you want to make the service handle tasks asynchronously, so it can start a task and continue working on others without waiting.

🎯 Goal: Build a Spring Boot application that demonstrates asynchronous processing by running a time-consuming task in the background while immediately responding to the user.

📋 What You'll Learn

Create a Spring Boot application with a REST controller

Add a method that simulates a long-running task

Configure asynchronous processing using @EnableAsync

Use @Async annotation to run the long task asynchronously

Return immediate response while the task runs in the background

💡 Why This Matters

🌍 Real World

Async processing helps web services handle slow tasks without making users wait, improving responsiveness and user experience.

💼 Career

Understanding async in Spring Boot is essential for backend developers building scalable and efficient web applications.

1

Create a REST controller with a long task method

Create a Spring Boot REST controller class named AsyncController with a method longTask that simulates a 5-second delay using Thread.sleep(5000) and returns the string "Task Completed".

Spring Boot

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class AsyncController {
    
    // Your code here
}

Hint

Use @RestController and @GetMapping("/longtask") annotations. Use Thread.sleep(5000) inside longTask method.

2

Enable asynchronous processing in the application

Create a configuration class named AsyncConfig and annotate it with @Configuration and @EnableAsync to enable asynchronous method execution.

Spring Boot

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {
    // Your code here
}

Hint

Use @Configuration and @EnableAsync annotations on the class.

3

Make the long task method asynchronous

Modify the longTask method in AsyncController to run asynchronously by adding the @Async annotation and changing its return type to CompletableFuture<String>. Wrap the result "Task Completed" in CompletableFuture.completedFuture().

Spring Boot

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.scheduling.annotation.Async;
import java.util.concurrent.CompletableFuture;

@RestController
public class AsyncController {
    
    @Async
    @GetMapping("/longtask")
    public CompletableFuture longTask() {
        // Your code here
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {
}

Hint

Add @Async above the method and change return type to CompletableFuture<String>. Return the string wrapped in CompletableFuture.completedFuture().

4

Add a quick response endpoint to show async behavior

Add a new method quickResponse in AsyncController mapped to /quick that immediately returns the string "Quick Response" to demonstrate the app can respond without waiting for the long task.

Spring Boot

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.scheduling.annotation.Async;
import java.util.concurrent.CompletableFuture;

@RestController
public class AsyncController {
    
    @Async
    @GetMapping("/longtask")
    public CompletableFuture longTask() {
        try {
            Thread.sleep(5000);
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }
        return CompletableFuture.completedFuture("Task Completed");
    }

    @GetMapping("/quick")
    public String quickResponse() {
        // Your code here
    }
}

import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;

@Configuration
@EnableAsync
public class AsyncConfig {
}

Hint

Add a method with @GetMapping("/quick") that returns "Quick Response" immediately.

Practice

1. Why is async processing important in Spring Boot applications?

easy

A. It makes the application use more memory by duplicating tasks.

B. It forces all tasks to run one after another in sequence.

C. It allows tasks to run in the background without blocking the main thread.

D. It disables error handling for faster execution.

Solution

1. Step 1: Understand async processing purpose

   Async processing lets tasks run separately from the main thread, so the app stays responsive.

2. Step 2: Identify correct behavior in Spring Boot

   Spring Boot uses @Async to run methods in the background, improving speed and user experience.

3. Final Answer:

   It allows tasks to run in the background without blocking the main thread. -> Option C

4. Quick Check:

   Async means background tasks = B [OK]

Hint: Async means background work without blocking main thread [OK]

Common Mistakes:

• Thinking async duplicates tasks unnecessarily
• Believing async forces sequential execution
• Assuming async disables error handling

2. Which annotation is used in Spring Boot to enable async processing on a method?

easy

A. @BackgroundTask

B. @EnableAsync

C. @AsyncMethod

D. @Async

Solution

1. Step 1: Recall Spring Boot async annotations

   @Async is the annotation placed on methods to run them asynchronously.

2. Step 2: Differentiate from other annotations

   @EnableAsync enables async support globally but is not placed on methods; @AsyncMethod and @BackgroundTask do not exist in Spring Boot.

3. Final Answer:

   @Async -> Option D

4. Quick Check:

   Method-level async annotation = A [OK]

Hint: Use @Async on methods to run them asynchronously [OK]

Common Mistakes:

• Confusing @EnableAsync with @Async
• Using non-existent annotations like @AsyncMethod
• Applying @Async on classes instead of methods

3. What will be the output behavior of this Spring Boot method annotated with @Async?

@Async
public CompletableFuture<String> fetchData() {
    // simulate delay
    Thread.sleep(1000);
    return CompletableFuture.completedFuture("Done");
}

medium

A. The method immediately returns a CompletableFuture, running the delay in the background.

B. The method returns null because async methods cannot return values.

C. The method throws a compile-time error due to Thread.sleep in async method.

D. The method blocks the caller for 1 second before returning "Done".

Solution

1. Step 1: Understand @Async with CompletableFuture

   @Async runs the method in a separate thread, so the caller gets a CompletableFuture immediately.

2. Step 2: Analyze Thread.sleep effect

   The delay happens inside the async thread, not blocking the caller thread.

3. Final Answer:

   The method immediately returns a CompletableFuture, running the delay in the background. -> Option A

4. Quick Check:

   @Async returns immediately with CompletableFuture = D [OK]

Hint: Async method returns CompletableFuture immediately, delay runs in background [OK]

Common Mistakes:

• Thinking Thread.sleep blocks the caller thread
• Assuming async methods cannot return values
• Believing async causes compile errors with sleep

4. Identify the error in this Spring Boot async method:

@Async
public void process() {
    CompletableFuture<String> result = CompletableFuture.supplyAsync(() -> {
        throw new RuntimeException("Fail");
    });
    System.out.println(result.get());
}

medium

A. Calling result.get() blocks the async thread, defeating async benefits.

B. Throwing RuntimeException inside supplyAsync is not allowed.

C. The method must return CompletableFuture<String>, not void.

D. Missing @EnableAsync annotation on the class.

Solution

1. Step 1: Analyze use of result.get()

   Calling get() waits for the CompletableFuture to finish, blocking the async thread.

2. Step 2: Understand async best practices

   Blocking defeats async purpose; exceptions inside supplyAsync are allowed and handled asynchronously.

3. Final Answer:

   Calling result.get() blocks the async thread, defeating async benefits. -> Option A

4. Quick Check:

   Blocking call inside async method = C [OK]

Hint: Avoid blocking calls like get() inside async methods [OK]

Common Mistakes:

• Thinking exceptions inside supplyAsync are disallowed
• Believing async methods must always return CompletableFuture
• Forgetting to enable async globally (not always required)

5. You want to improve a Spring Boot app's responsiveness by running multiple independent tasks in parallel. Which approach best uses async processing to achieve this?

hard

A. Run all tasks sequentially in the main thread to avoid thread overhead.

B. Annotate each task method with @Async and return CompletableFuture, then combine results with CompletableFuture.allOf().

C. Use @Async but return void from all methods to simplify code.

D. Create new threads manually inside each method without @Async.

Solution

1. Step 1: Identify best async pattern for parallel tasks

   Using @Async with CompletableFuture allows tasks to run in parallel and return results.

2. Step 2: Combine results properly

   CompletableFuture.allOf() waits for all async tasks to finish, enabling coordinated processing.

3. Final Answer:

   Annotate each task method with @Async and return CompletableFuture, then combine results with CompletableFuture.allOf(). -> Option B

4. Quick Check:

   Parallel async tasks + combine results = A [OK]

Hint: Use @Async + CompletableFuture.allOf() for parallel task coordination [OK]

Common Mistakes:

• Running tasks sequentially loses async benefits
• Returning void loses ability to track task completion
• Manually creating threads ignores Spring Boot async support