采用阻塞IO的Spring Boot是否真的适合微服务架构？

你说得完全在点子上——传统阻塞式的Spring MVC确实会在这种多下游HTTP调用的场景下很快遇到线程资源耗尽的问题！

问题根源 #

每个进来的请求都会占用一个Tomcat（或其他Servlet容器）线程，而这个线程会一直阻塞到三次下游服务的HTTP响应全部返回。如果并发量上来，线程池里的线程很快就会被占满，后续请求只能排队等待，甚至直接被拒绝服务，系统吞吐量会急剧下降。

可行的解决方案 #

1. 基于CompletableFuture的异步调用

不用切换架构，在现有Spring MVC基础上就能实现。通过@Async注解把下游服务的调用改成异步执行，用CompletableFuture来并行处理这三个请求，最后合并结果。

首先要在配置类上开启异步支持：

@Configuration
@EnableAsync
public class AsyncConfig {
    @Bean
    public Executor asyncExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("Async-");
        executor.initialize();
        return executor;
    }
}

然后编写异步的服务调用方法：

@Service
public class DownstreamService {
    private final RestTemplate restTemplate;

    public DownstreamService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @Async
    public CompletableFuture<User> fetchUser(Long userId) {
        User user = restTemplate.getForObject("http://user-service/users/{id}", User.class, userId);
        return CompletableFuture.completedFuture(user);
    }

    @Async
    public CompletableFuture<Stats> fetchUserStats(Long userId) {
        Stats stats = restTemplate.getForObject("http://stats-service/stats/{id}", Stats.class, userId);
        return CompletableFuture.completedFuture(stats);
    }

    @Async
    public CompletableFuture<List<Friend>> fetchUserFriends(Long userId) {
        List<Friend> friends = restTemplate.exchange(
                "http://friend-service/friends/{id}",
                HttpMethod.GET,
                null,
                new ParameterizedTypeReference<List<Friend>>() {},
                userId
        ).getBody();
        return CompletableFuture.completedFuture(friends);
    }
}

最后在Controller里并行调用并合并结果：

@RestController
@RequestMapping("/profiles")
public class UserProfileController {
    private final DownstreamService downstreamService;

    public UserProfileController(DownstreamService downstreamService) {
        this.downstreamService = downstreamService;
    }

    @GetMapping("/{userId}")
    public ResponseEntity<UserProfile> getUserProfile(@PathVariable Long userId) throws InterruptedException, ExecutionException {
        // 并行发起三个异步请求
        CompletableFuture<User> userFuture = downstreamService.fetchUser(userId);
        CompletableFuture<Stats> statsFuture = downstreamService.fetchUserStats(userId);
        CompletableFuture<List<Friend>> friendsFuture = downstreamService.fetchUserFriends(userId);

        // 等待所有请求完成
        CompletableFuture.allOf(userFuture, statsFuture, friendsFuture).join();

        // 组装结果
        UserProfile profile = new UserProfile(
                userFuture.get(),
                statsFuture.get(),
                friendsFuture.get()
        );
        return ResponseEntity.ok(profile);
    }
}

2. 切换到Spring WebFlux（反应式编程）

这是更彻底的非阻塞方案，用WebClient代替RestTemplate，整个请求处理链路都是非阻塞的，只需要少量线程就能支撑高并发。

示例代码：

@RestController
@RequestMapping("/profiles")
public class ReactiveUserProfileController {
    private final WebClient webClient;

    public ReactiveUserProfileController(WebClient.Builder webClientBuilder) {
        this.webClient = webClientBuilder.build();
    }

    @GetMapping("/{userId}")
    public Mono<UserProfile> getUserProfile(@PathVariable Long userId) {
        // 并行发起三个非阻塞请求
        Mono<User> userMono = webClient.get()
                .uri("http://user-service/users/{id}", userId)
                .retrieve()
                .bodyToMono(User.class);

        Mono<Stats> statsMono = webClient.get()
                .uri("http://stats-service/stats/{id}", userId)
                .retrieve()
                .bodyToMono(Stats.class);

        Mono<List<Friend>> friendsMono = webClient.get()
                .uri("http://friend-service/friends/{id}", userId)
                .retrieve()
                .bodyToFlux(Friend.class)
                .collectList();

        // 合并三个Mono的结果
        return Mono.zip(userMono, statsMono, friendsMono)
                .map(tuple -> new UserProfile(tuple.getT1(), tuple.getT2(), tuple.getT3()));
    }
}

这种方式下，处理请求的线程不会被阻塞在等待下游响应上，线程利用率大幅提升，能轻松应对高并发场景。

3. 临时优化：调整线程池配置（治标不治本）

如果暂时无法重构代码，可以先调整Servlet容器的线程池参数，比如Tomcat的max-threads和accept-count，同时给下游HTTP调用设置合理的超时时间，避免线程被长时间占用。但这只是权宜之计，并发量上来后还是会遇到瓶颈。

总结 #

如果你的服务并发压力较大，优先推荐Spring WebFlux的非阻塞方案；如果不想大规模重构现有代码，用CompletableFuture的异步调用也能有效缓解线程耗尽的问题。

内容的提问来源于stack exchange，提问作者Teimuraz