java
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.method.HandlerMethod;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.concurrent.atomic.AtomicInteger;

@Slf4j
@Component
public class RequestConcurrencyInterceptor implements HandlerInterceptor {
    /**
     * 原子计数器：当前正在处理的Controller业务请求并发数
     * 仅统计接口方法，静态资源、websocket、过滤器逻辑不计入
     */
    private final AtomicInteger concurrentReq = new AtomicInteger(0);

    /**
     * Controller执行前计数+1
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
        // 只拦截@RestController/@Controller中的方法
        if (handler instanceof HandlerMethod) {
            concurrentReq.incrementAndGet();
        }
        return true;
    }

    /**
     * 请求完全处理完毕（正常返回/抛出异常都会执行）计数-1
     */
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) {
        if (handler instanceof HandlerMethod) {
            concurrentReq.decrementAndGet();
        }
    }

    /**
     * 对外暴露获取实时业务并发
     * @return 当前正在处理的Controller请求数量
     */
    public int getCurrentConcurrency() {
        return concurrentReq.get();
    }
}

java
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import javax.annotation.Resource;

@Configuration
public class WebConfig implements WebMvcConfigurer {

    @Resource
    private RequestConcurrencyInterceptor interceptor;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 拦截全部路径，内部自动过滤非Controller请求
        registry.addInterceptor(interceptor)
                .addPathPatterns("/**");
    }
}

java
import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardThreadExecutor;
import org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.annotation.Resource;
import java.util.HashMap;
import java.util.Map;

@RestController
public class TomcatQueueMonitorController {

    @Resource
    private ServletWebServerApplicationContext webServerCtx;
    @Resource
    private RequestConcurrencyInterceptor concurrencyInterceptor;

    /**
     * 完整Tomcat监控指标接口
     * 1. 业务真实并发（拦截器统计）
     * 2. Tomcat线程池排队等待请求数
     * 3. Tomcat活跃工作线程数
     * 4. 最大线程上限、当前线程池总大小
     */
    @GetMapping("/monitor/tomcat/stat")
    public Map<String, Object> getTomcatFullStat() {
        // 获取第一个端口的Tomcat连接器
        Connector connector = webServerCtx.getWebServer().getConnectors()[0];
        StandardThreadExecutor executor = (StandardThreadExecutor) connector.getProtocolHandler().getExecutor();

        Map<String, Object> result = new HashMap<>(8);
        // 1. 拦截器统计：仅Controller业务请求并发（推荐业务监控使用）
        result.put("businessConcurrency", concurrencyInterceptor.getCurrentConcurrency());
        // 2. Tomcat底层活跃工作线程（包含静态资源、长连接等）
        result.put("tomcatActiveThread", executor.getActiveCount());
        // 3. 队列中排队未分配线程的请求堆积数（核心预警指标）
        result.put("waitQueueSize", executor.getQueueSize());
        // 4. Tomcat配置最大工作线程
        result.put("maxThreads", executor.getMaxThreads());
        // 5. 当前线程池已创建总线程
        result.put("currentPoolSize", executor.getPoolSize());
        return result;
    }

    /**
     * 单独获取排队堆积请求数（兼容旧逻辑）
     */
    @GetMapping("/monitor/tomcat/queue")
    public long getWaitRequestCount() {
        Connector connector = webServerCtx.getWebServer().getConnectors()[0];
        StandardThreadExecutor executor = (StandardThreadExecutor) connector.getProtocolHandler().getExecutor();
        return executor.getQueueSize();
    }
}

字段

含义

线上风险判断

businessConcurrency

拦截器统计，正在处理的业务接口并发

业务流量真实水位，压测、限流参考值

tomcatActiveThread

Tomcat 活跃工作线程总数

包含静态资源、websocket，数值通常大于 businessConcurrency

waitQueueSize

排队等待线程的请求堆积数量

1. tomcatActiveThread == maxThreads 且 waitQueueSize 持续上涨 → 服务处理能力不足，大量请求排队超时
2. waitQueueSize 长期 > 50 需告警

maxThreads

Tomcat 最大工作线程（默认 200）

可通过server.tomcat.threads.max调大

currentPoolSize

线程池已创建线程总数

冷启动缓慢扩容，流量平稳后稳定

yaml
server:
  tomcat:
    mbeanregistry: enabled: true
management:
  endpoints:
    web:
      exposure: include: metrics,prometheus

yaml
server:
  tomcat:
    threads:
      max: 400
      min-spare: 50
    accept-count: 200