通过代码/API查看Tomcat的maxThreads参数

import org.springframework.beans.factory.annotation.Value;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 读取配置文件中的 maxThreads 参数
 */
@RestController
public class TomcatConfigSimpleController {

    // 读取 application.yml/application.properties 中的配置值
    @Value("${server.tomcat.threads.max:200}") // 200 是默认值（未配置时返回）
    private int maxThreads;

    @GetMapping("/tomcat/maxThreads/simple")
    public String getMaxThreadsSimple() {
        return String.format("Spring Boot 配置的 maxThreads: %d", maxThreads);
    }
}

import org.apache.catalina.connector.Connector;
import org.apache.coyote.http11.Http11NioProtocol;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.web.embedded.tomcat.TomcatWebServer;
import org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 获取 Tomcat 运行时实际生效的 maxThreads 参数
 */
@RestController
public class TomcatConfigController {

    // 注入 Spring Boot Web 容器上下文
    @Autowired
    private ServletWebServerApplicationContext applicationContext;

    @GetMapping("/tomcat/maxThreads")
    public String getTomcatMaxThreads() {
        try {
            // 1. 获取 Spring Boot 封装的 TomcatWebServer
            TomcatWebServer tomcatWebServer = (TomcatWebServer) applicationContext.getWebServer();
            
            // 2. 获取 Tomcat 的 Service 组件（默认名称为 "Tomcat"）
            org.apache.catalina.Service service = tomcatWebServer.getTomcat().getService();
            
            // 3. 获取 Connector（默认第一个 Connector 是 8080 端口的 HTTP 连接器）
            Connector connector = service.getConnectors()[0];
            
            // 4. 获取协议处理器（NIO 模型对应 Http11NioProtocol）
            Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
            
            // 5. 获取核心参数
            int maxThreads = protocol.getMaxThreads();
            int minSpareThreads = protocol.getMinSpareThreads();
            int acceptCount = protocol.getAcceptCount();
            int maxConnections = protocol.getMaxConnections();

            // 组装返回结果
            return String.format(
                "Tomcat 运行时参数：<br/>" +
                "maxThreads: %d<br/>" +
                "minSpareThreads: %d<br/>" +
                "acceptCount: %d<br/>" +
                "maxConnections: %d",
                maxThreads, minSpareThreads, acceptCount, maxConnections
            );
        } catch (Exception e) {
            return "获取 Tomcat 参数失败：" + e.getMessage();
        }
    }
}

Tomcat 运行时参数：
maxThreads: 800
minSpareThreads: 50
acceptCount: 500
maxConnections: 20000

<dependency>
    <groupId>org.apache.tomcat</groupId>
    <artifactId>tomcat-catalina</artifactId>
    <version>9.0.80</version> <!-- 与你的 Tomcat 版本一致 -->
    <scope>provided</scope> <!-- 外置 Tomcat 已提供，无需打包 -->
</dependency>

import org.apache.catalina.connector.Connector;
import org.apache.catalina.core.StandardServer;
import org.apache.coyote.http11.Http11NioProtocol;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;

/**
 * 外置 Tomcat 中获取 maxThreads 参数
 */
@WebServlet("/tomcat/maxThreads")
public class TomcatMaxThreadsServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html;charset=UTF-8");
        PrintWriter out = response.getWriter();

        try {
            // 1. 从 ServletContext 获取 Tomcat StandardServer 实例
            StandardServer server = (StandardServer) getServletContext()
                    .getAttribute("org.apache.catalina.core.StandardServer.INSTANCE");

            // 2. 获取默认 Service（名称为 "Catalina"）
            org.apache.catalina.Service service = server.findService("Catalina");

            // 3. 获取 8080 端口的 Connector（可遍历筛选）
            Connector connector = null;
            for (Connector c : service.getConnectors()) {
                // 筛选 HTTP 连接器（排除 AJP 连接器，如 8009 端口）
                if (c.getPort() == 8080 && c.getProtocolHandler() instanceof Http11NioProtocol) {
                    connector = c;
                    break;
                }
            }

            if (connector == null) {
                out.write("未找到 8080 端口的 HTTP Connector");
                return;
            }

            // 4. 获取协议处理器并读取参数
            Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
            int maxThreads = protocol.getMaxThreads();
            int minSpareThreads = protocol.getMinSpareThreads();
            int acceptCount = protocol.getAcceptCount();

            // 输出结果
            out.write("外置 Tomcat 运行时参数：<br/>");
            out.write("maxThreads: " + maxThreads + "<br/>");
            out.write("minSpareThreads: " + minSpareThreads + "<br/>");
            out.write("acceptCount: " + acceptCount);

        } catch (Exception e) {
            out.write("获取参数失败：" + e.getMessage());
            e.printStackTrace(out);
        } finally {
            out.close();
        }
    }
}