“Tomcat最大支持多少个请求”

前置说明

这里的Tomcat，指的是默认SpringBoot内嵌Tomcat（不修改任何配置）。

对于“Tomcat默认可以处理多少个请求”的解读，按照时间颗粒度不同，有两种理解角度，一种是并行处理，另一种是并发处理（QPS）。

• 并行处理
  Tomcat的请求处理线程池，默认设置的“最大线程数”（默认maximumPoolSize为200），即Tomcat支持并行处理的请求数。
  org.apache.tomcat.util.net.AbstractEndpoint
  

• 并发处理（QPS）
  单位时间1s内，基于Tomcat最大线程数（200），能接受处理的请求数。
  假如一个请求响应时间（RT）为200ms，则默认Tomcat的理想QPS为1000。

源码走读

SpringBoot启动

Tomcat容器的启动位于上下文刷新的finishRefresh()方法中。

执行栈帧

finishRefresh()方法

WebServer接口为服务容器根接口，SpringBoot默认容器为Tomcat。

Tomcat容器启动

执行堆栈

直接跟踪到线程池创建部分

    public void createExecutor() {
        internalExecutor = true;
        // 创建自定义等待队列
        TaskQueue taskqueue = new TaskQueue();
        // 创建 线程生成工程
        TaskThreadFactory tf = new TaskThreadFactory(getName() + "-exec-", daemon, getThreadPriority());
        // 创建请求处理线程池
        executor = new ThreadPoolExecutor(getMinSpareThreads(), getMaxThreads(), 60, TimeUnit.SECONDS,taskqueue, tf);
        // 保存线程池到队列属性中
        taskqueue.setParent( (ThreadPoolExecutor) executor);
    }

这便是Tomcat请求处理线程池的创建，debug该线程池的属性

可以看得出来，线程池核心线程数为10，最大线程数为200。
对于该线程池的等待队列，是Tomcat自定义的TaskQueue（上面的org.apache.tomcat.util.net.AbstractEndpoint#createExecutor方法中创建）。

自定义等待队列TaskQueue中有一个属性parent，通过重写队列的org.apache.tomcat.util.threads.TaskQueue#offer方法，实现请求拒绝策略。

public class TaskQueue extends LinkedBlockingQueue<Runnable> {

    private volatile ThreadPoolExecutor parent = null;

    @Override
    public boolean offer(Runnable o) {
      	//we can't do any checks
      	// 如果未设置线程池，则直接入队
        if (parent==null) return super.offer(o);
        //we are maxed out on threads, simply queue the object
        // 如果线程数 == 最大线程数，则直接入队
        if (parent.getPoolSize() == parent.getMaximumPoolSize()) return super.offer(o);
        //we have idle threads, just add it to the queue
        // 如果已提交任务数（提交但未完成） <= 线程数，直接入队
        if (parent.getSubmittedCount()<=(parent.getPoolSize())) return super.offer(o);
        //if we have less threads than maximum force creation of a new thread
        // -----------------------------------------------------------------
        // 如果线程数 < 最大线程数，不入队，返回false，强制创建新的工作线程
        // -----------------------------------------------------------------
        if (parent.getPoolSize()<parent.getMaximumPoolSize()) return false;
        //if we reached here, we need to add it to the queue
        // 以上条件不符合，则直接入队
        return super.offer(o);
    }
}

这里可以看到，Tomcat的请求线程池的任务提交和常规的线程池任务提交有一定区别，
常规线程池的等待队列，基本只负责按照队列属性进行入队，直接返回入队成功或者失败。
而Tomcat的线程池任务等待队列，在常规线程池任务提交逻辑上，加入了线程池本身的运行状态作为入队的判断条件，最主要的一个差别是：
Tomcat中，如果线程数小于最大核心线程数，不管等待队列是否可以入队，会直接创建新的工作线程执行任务。
常规线程池的做法是，等待队列满了才会创建新的工作线程去执行任务。

Tomcat线程池处理请求

public abstract class AbstractEndpoint<S> {
    public boolean processSocket(SocketWrapperBase<S> socketWrapper,
            SocketEvent event, boolean dispatch) {
        try {
            if (socketWrapper == null) {
                return false;
            }
            // 获取缓存中的socket任务
            SocketProcessorBase<S> sc = processorCache.pop();
            if (sc == null) {
            	// 缓存为空，则创建（拉取）新的socket任务
                sc = createSocketProcessor(socketWrapper, event);
            } else {
            	// 缓存不为空，则重置socket事件
                sc.reset(socketWrapper, event);
            }
            // 获取线程池
            Executor executor = getExecutor();
            if (dispatch && executor != null) {
            	// 提交任务
                executor.execute(sc);
            } else {
                sc.run();
            }
        } catch (RejectedExecutionException ree) {
            getLog().warn(sm.getString("endpoint.executor.fail", socketWrapper) , ree);
            return false;
        } catch (Throwable t) {
            ExceptionUtils.handleThrowable(t);
            // This means we got an OOM or similar creating a thread, or that
            // the pool and its queue are full
            getLog().error(sm.getString("endpoint.process.fail"), t);
            return false;
        }
        return true;
    }

}

SocketProcessorBase为Socket处理任务基础抽象类。

通过继承该类，实现doRun()抽象方法，实现不同的线程模型。

debug可知，Tomcat默认使用的线程模型为NIO。

官网线程模型
链接：https://tomcat.apache.org/tomcat-8.0-doc/config/http.html

注意，这里的阻塞非阻塞，是针对请求的读取和响应，而非请求本身的逻辑（Controller方法）。

总结

Tomcat默认最大并行处理数为200，并发处理数 QPS = 200 * (1000ms / 平均RT)。