Implementing Asynchronous Processing in Spring Boot: ThreadPool, @Async, and Message Queue Approaches

In daily development we sometimes need to modify data in multiple tables in an ordered way; using a single‑threaded synchronous approach can cause timeouts, long response times, and poor user experience.

The article first shows a simple synchronous implementation with a @RestController that calls a service method which iterates over a list and sleeps to simulate work.

1. Using a ThreadPool

A controller creates a ThreadPoolExecutor (corePoolSize 1, maxPoolSize 5, keepAlive 50000 ms, LinkedBlockingQueue) and submits the service task to it, allowing the main thread to return a response immediately while the pool thread processes the business logic.

@RestController
public class TestAsyncController {

    @Autowired
    private TestAsyncService asyncService;

    /**
     * 使用传统方式测试
     */
    @GetMapping("/test")
    public void test() {
        System.out.println("获取主线程名称：" + Thread.currentThread().getName());
        /**
         * 这里也可以采用以下方式使用，但是使用线程池的方式可以很便捷的对线程管理（提高程序的整体性能），
         * 也可以减少每次执行该请求时都需要创建一个线程造成的性能消耗
         * new Thread(() ->{
         *   run方法中的业务逻辑
         * })
         */
        /**
         * 定义一个线程池
         * 核心线程数（corePoolSize）:1
         * 最大线程数（maximumPoolSize）: 1
         * 保持连接时间（keepAliveTime）：50000
         * 时间单位 (TimeUnit):TimeUnit.MILLISECONDS(毫秒)
         * 阻塞队列 new LinkedBlockingQueue<Runnable>()
         */
        ThreadPoolExecutor executor = new ThreadPoolExecutor(1,5,50000, TimeUnit.MILLISECONDS, new LinkedBlockingQueue<Runnable>());
        // 执行业务逻辑方法serviceTest()
        executor.execute(new Runnable() {
            @Override
            public void run() {
                asyncService.serviceTest();
            }
        });
        System.out.println("执行完成，向用户响应成功信息");
    }
}

Running the request shows that the main thread returns quickly while the pool thread prints the numbers, reducing the perceived latency.

2. Using @EnableAsync and @Async

Spring can manage the thread pool automatically. By adding @EnableAsync to a configuration class and annotating the service method with @Async, the method runs asynchronously without explicit pool code, simplifying development.

@RestController
public class TestAsyncController {

    @Autowired
    private TestAsyncService asyncService;

    /**
     * 使用 @Async 来实现
     */
    @GetMapping("/test")
    public void test() {
        System.out.println("获取主线程名称：" + Thread.currentThread().getName());
        // 异步调用
        asyncService.serviceTest();
        System.out.println("执行完成，向用户响应成功信息");
    }
}

@Service
@EnableAsync
public class TestAsyncService {

    /**
     * 采用异步执行
     */
    @Async
    public void serviceTest() {
        // 这里执行实际的业务逻辑，在这里我们就是用一个简单的遍历来模拟
        Arrays.stream(new int[]{1,2,3,4,5,6,7,8,9,10}).forEach( t -> {
            try {
                Thread.sleep(100);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            System.out.println("获取number为:" + t);
        });
    }
}

The execution result matches the thread‑pool approach, but the code is shorter and Spring handles thread‑pool configuration.

3. Using a Message Queue (MQ)

When a request needs to process a massive amount of data, using @Async may still overload the server. Decoupling business logic from non‑business tasks via a message queue isolates the workloads, prevents server crashes, and improves overall system stability. The article mentions that a future implementation will demonstrate this approach.