Spring Boot-Tomcat多租户：为每个租户配置独立线程池

针对你需要按客户端路径隔离线程池的需求，优先推荐基于Spring MVC RequestMappingHandlerMapping + 专属TaskExecutor的实现方案，完全利用Spring原生能力，无需修改Tomcat底层或新增端口，配置简洁且易于维护。

方案一：Spring MVC HandlerMapping 专属线程池配置 #

每个客户端的API路径对应独立的RequestMappingHandlerMapping，并为每个映射配置专属线程池，请求匹配到对应路径后会自动使用专属线程池处理，天然实现隔离。

具体实现代码 #

@Configuration
public class ClientThreadPoolConfig {

    // Foo客户端专属线程池
    @Bean("fooTaskExecutor")
    public TaskExecutor fooTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(20);
        executor.setThreadNamePrefix("foo-exec-");
        executor.initialize();
        return executor;
    }

    // Bar客户端专属线程池
    @Bean("barTaskExecutor")
    public TaskExecutor barTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(5);
        executor.setMaxPoolSize(10);
        executor.setQueueCapacity(20);
        executor.setThreadNamePrefix("bar-exec-");
        executor.initialize();
        return executor;
    }

    // 默认全局线程池（处理非客户端专属路径）
    @Bean("defaultTaskExecutor")
    public TaskExecutor defaultTaskExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(50);
        executor.setThreadNamePrefix("default-exec-");
        executor.initialize();
        return executor;
    }

    // Foo客户端专属请求映射，优先级最高
    @Bean
    public RequestMappingHandlerMapping fooRequestMappingHandlerMapping(@Qualifier("fooTaskExecutor") TaskExecutor executor) {
        RequestMappingHandlerMapping mapping = new RequestMappingHandlerMapping();
        mapping.setPathPrefix("/api/foo"); // 绑定Foo客户端路径前缀
        mapping.setTaskExecutor(executor); // 绑定专属线程池
        mapping.setOrder(0); // 优先级高于其他映射，确保优先匹配
        return mapping;
    }

    // Bar客户端专属请求映射
    @Bean
    public RequestMappingHandlerMapping barRequestMappingHandlerMapping(@Qualifier("barTaskExecutor") TaskExecutor executor) {
        RequestMappingHandlerMapping mapping = new RequestMappingHandlerMapping();
        mapping.setPathPrefix("/api/bar");
        mapping.setTaskExecutor(executor);
        mapping.setOrder(1);
        return mapping;
    }

    // 默认请求映射，处理剩余路径
    @Bean
    public RequestMappingHandlerMapping defaultRequestMappingHandlerMapping(@Qualifier("defaultTaskExecutor") TaskExecutor executor) {
        RequestMappingHandlerMapping mapping = new RequestMappingHandlerMapping();
        mapping.setTaskExecutor(executor);
        mapping.setOrder(2);
        return mapping;
    }
}

方案优势 #

• 完全基于Spring原生组件，无需依赖额外扩展
• 线程池与请求路径绑定逻辑清晰，易于维护和扩展新客户端
• 自动管理请求上下文，避免异步处理中的上下文丢失问题

方案二：Tomcat Valve 线程池路由（底层定制方案） #

如果需要更底层的Tomcat请求链控制，可以通过自定义Valve实现请求路径到线程池的路由，适合需要对Tomcat处理逻辑做更多定制的场景。

具体实现代码 #

自定义线程池路由Valve

public class ClientThreadPoolRoutingValve extends ValveBase {

    private final Map<String, Executor> clientExecutors;
    private final Executor defaultExecutor;

    public ClientThreadPoolRoutingValve(Map<String, Executor> clientExecutors, Executor defaultExecutor) {
        this.clientExecutors = clientExecutors;
        this.defaultExecutor = defaultExecutor;
    }

    @Override
    public void invoke(Request request, Response response) throws IOException, ServletException {
        String requestURI = request.getRequestURI();
        Executor targetExecutor = defaultExecutor;

        // 根据路径匹配对应客户端线程池
        if (requestURI.startsWith("/api/foo/")) {
            targetExecutor = clientExecutors.get("fooExecutor");
        } else if (requestURI.startsWith("/api/bar/")) {
            targetExecutor = clientExecutors.get("barExecutor");
        }

        // 将请求提交到目标线程池处理
        if (targetExecutor != null) {
            targetExecutor.execute(() -> {
                try {
                    getNext().invoke(request, response);
                } catch (IOException | ServletException e) {
                    throw new RuntimeException(e);
                }
            });
        } else {
            getNext().invoke(request, response);
        }
    }
}

配置Tomcat并添加Valve

@Configuration
public class TomcatConfig implements WebServerFactoryCustomizer<TomcatServletWebServerFactory> {

    @Override
    public void customize(TomcatServletWebServerFactory factory) {
        // 初始化各客户端线程池
        ThreadPoolExecutor fooExecutor = new ThreadPoolExecutor(
                5, 10, 60, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(20),
                r -> new Thread(r, "foo-exec-" + new AtomicInteger().incrementAndGet())
        );

        ThreadPoolExecutor barExecutor = new ThreadPoolExecutor(
                5, 10, 60, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(20),
                r -> new Thread(r, "bar-exec-" + new AtomicInteger().incrementAndGet())
        );

        ThreadPoolExecutor defaultExecutor = new ThreadPoolExecutor(
                10, 20, 60, TimeUnit.SECONDS,
                new ArrayBlockingQueue<>(50),
                r -> new Thread(r, "default-exec-" + new AtomicInteger().incrementAndGet())
        );

        Map<String, Executor> clientExecutors = new HashMap<>();
        clientExecutors.put("fooExecutor", fooExecutor);
        clientExecutors.put("barExecutor", barExecutor);

        // 将自定义Valve添加到Tomcat引擎
        factory.addEngineValves(new ClientThreadPoolRoutingValve(clientExecutors, defaultExecutor));
    }
}

方案说明 #

• 直接在Tomcat请求处理链中拦截请求，路由到对应线程池
• 适合需要绕过Spring MVC直接控制Tomcat线程模型的场景
• 需要注意Valve的执行顺序，确保在核心业务Valve之前执行

方案对比与选择 #

你之前考虑的Filter方案不可行，因为Filter运行在Tomcat容器线程中，即使手动提交到自定义线程池，也无法保证Spring MVC后续处理的上下文一致性；而自定义委托Executor的思路和Valve方案类似，但Valve实现更直接可控。

多端口方案确实会增加基础设施复杂度，完全不推荐。

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