Using Asynchronous Methods in Spring Boot: Concepts, Implementation, and Best Practices

The article introduces the need for asynchronous methods in business interfaces, showing that separating independent tasks such as sending verification codes or updating article read counts can dramatically speed up response times.

It compares synchronous execution (single‑thread) with asynchronous execution (additional threads) and includes illustrative diagrams.

Spring Boot asynchronous support is demonstrated by enabling it with @EnableAsync and marking methods with @Async. The default executor is SimpleAsyncTaskExecutor.

@EnableAsync // enable async support
@Async // method will be executed asynchronously

Service layer example shows a method that fetches an article and an @Async method that updates the read count with a simulated delay.

@Service
public class ArticleServiceImpl {
    public String selectArticle() {
        System.out.println("查询任务线程" + Thread.currentThread().getName());
        return "文章详情";
    }

    @Async
    public void updateReadCount() {
        try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }
        System.out.println("更新任务线程" + Thread.currentThread().getName());
    }
}

Controller layer example calls the service methods, demonstrating that the read‑count update runs in a separate thread while the article is returned immediately.

@RestController
public class AsyncTestController {
    @Autowired
    private ArticleServiceImpl articleService;

    @PostMapping("/article")
    public String getArticle() {
        String article = articleService.selectArticle();
        articleService.updateReadCount();
        System.out.println("文章阅读业务执行完毕");
        return article;
    }
}

Custom thread‑pool configuration creates a ThreadPoolTaskExecutor with specific core size, max size, queue capacity, keep‑alive time, and naming conventions.

@EnableAsync
@Configuration
public class AsyncConfig {
    @Bean("customExecutor")
    public ThreadPoolTaskExecutor asyncOperationExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(8);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(Integer.MAX_VALUE);
        executor.setKeepAliveSeconds(60);
        executor.setThreadNamePrefix("AsyncOperationThread-");
        executor.setThreadGroupName("AsyncOperationGroup");
        executor.setWaitForTasksToCompleteOnShutdown(true);
        executor.initialize();
        return executor;
    }
}

To use the custom pool, specify its name in the @Async annotation.

@Async("customExecutor")
public void updateReadCount() { /* same implementation */ }

Exception handling for async methods is achieved by implementing AsyncConfigurer and providing an AsyncUncaughtExceptionHandler that logs the exception, method name, and parameters.

@EnableAsync
@Configuration
public class AsyncConfig implements AsyncConfigurer {
    @Override
    public Executor getAsyncExecutor() { /* same executor as above */ }
    @Override
    public AsyncUncaughtExceptionHandler getAsyncUncaughtExceptionHandler() {
        return new CustomAsyncExceptionHandler();
    }
}

public class CustomAsyncExceptionHandler implements AsyncUncaughtExceptionHandler {
    @Override
    public void handleUncaughtException(Throwable ex, Method method, Object... params) {
        System.out.println("异常捕获---------------------------------");
        System.out.println("Exception message - " + ex.getMessage());
        System.out.println("Method name - " + method.getName());
        for (Object p : params) {
            System.out.println("Parameter value - " + p);
        }
        System.out.println("异常捕获---------------------------------");
    }
}

Returning values from async methods uses CompletableFuture. The example shows an async method returning a future integer and the controller waiting for the result.

@Async
public CompletableFuture<Integer> updateReadCountHasResult() {
    try { Thread.sleep(3000); } catch (InterruptedException e) { e.printStackTrace(); }
    System.out.println("更新文章阅读量线程" + Thread.currentThread().getName());
    return CompletableFuture.completedFuture(101);
}

@GetMapping("/article")
public String getArticle() throws ExecutionException, InterruptedException {
    String article = articleService.selectArticle();
    CompletableFuture<Integer> future = articleService.updateReadCountHasResult();
    int count = 0;
    while (true) {
        if (future.isCancelled()) { break; }
        if (future.isDone()) { count = future.get(); break; }
    }
    System.out.println("文章阅读业务执行完毕");
    return article + count;
}

The article concludes with a discussion of limitations and extensions of async methods: they must be placed in service classes, may not work when called from the same class, interaction with transactions, reliability concerns for strong‑consistency scenarios, and the suggestion to use message‑queue middleware such as RabbitMQ or Kafka for more robust asynchronous processing.