Introduction

Allows operations (I/O, external API calls, email sending, batch processing, ...) to run separately from the main request thread, improving:

• Throughput
• Response time
• System scalability

SpringBoot

application.yaml

spring:
	task:
		execution:
			pool:
				core-size: 10
				max-size=: 50
				queue-capacity: 200
			thread-name-prefix: my-async-

Common Approaches in Spring Boot

1. @Async

   • Annotation-based, Thread Pool
   • AOP Proxy
     • If you call an async method inside the same class, it will NOT be asynchronous.
     • Should call from another bean / inject self proxy.
   • For short concurrent tasks

   @Service
   public class AsyncService {
   
       @Async("taskExecutor")
       public CompletableFuture<String> asyncTask(String name) {
           try {
               Thread.sleep(2000); // simulate delay
           } catch (InterruptedException ignored) {}
   
           return CompletableFuture.completedFuture("hello " + name);
       }
   
       @Async("taskExecutor")
       public void asyncVoidTask() {
           throw new RuntimeException("oops");
       }
   }
   

   Usage:

   @RestController
   public class TestController {
   
       private final AsyncService asyncService;
   
       public TestController(AsyncService asyncService) {
           this.asyncService = asyncService;
       }
   
       @GetMapping("/test")
       public String test() throws Exception {
           CompletableFuture<String> future =
                   asyncService.asyncTask("world");
   
           String result = future.get(3, TimeUnit.SECONDS); // careful: blocking
           return "result: " + result;
       }
   }
   

2. CompletableFuture / Future / ListenableFuture

3. Reactor (Mono/Flux) / WebFlux

   • For reactive non-blocking programming
   • For heavy I/O-intensive workload
     • since threads will exhaust or queue may fill up if using thread pool

   Mono.fromCallable(() -> blockingCall())
       .subscribeOn(Schedulers.boundedElastic())
       .map(result -> ...)