面试官:一个 SpringBoot 项目能处理多少请求?(小心有坑)
你好呀,我是歪歪。
这篇文章带大家盘一个读者遇到的面试题哈。
根据读者转述,面试官的原问题就是:一个 SpringBoot 项目能同时处理多少请求?
不知道你听到这个问题之后的第一反应是什么。
我大概知道他要问的是哪个方向,但是对于这种只有一句话的面试题,我的第一反应是:会不会有坑?
所以并不会贸然答题,先追问一些消息,比如:这个项目具体是干什么的?项目大概进行了哪些参数配置?使用的 web 容器是什么?部署的服务器配置如何?有哪些接口?接口响应平均时间大概是多少?
这样,在几个问题的拉扯之后,至少在面试题考察的方向方面能基本和面试官达成了一致。
比如前面的面试问题,经过几次拉扯之后,面试官可能会修改为:
一个 SpringBoot 项目,未进行任何特殊配置,全部采用默认设置,这个项目同一时刻,最多能同时处理多少请求?
能处理多少呢?
我也不知道,但是当问题变成上面这样之后,我找到了探索答案的角度。
既然“未进行任何特殊配置”,那我自己搞个 Demo 出来,压一把不就完事了吗?
坐稳扶好,准备发车。
Demo
小手一抖,先搞个 Demo 出来。
这个 Demo 非常的简单,就是通过 idea 创建一个全新的 SpringBoot 项目就行。
我的 SpringBoot 版本使用的是 2.7.13。
整个项目只有这两个依赖:
整个项目也只有两个类,要得就是一个空空如也,一清二白。
项目中的 TestController,里面只有一个 getTest 方法,用来测试,方法里面接受到请求之后直接 sleep 一小时。
目的就是直接把当前请求线程占着,这样我们才能知道项目中一共有多少个线程可以使用:
@Slf4j
@RestController
public class TestController {
@GetMapping("/getTest")
public void getTest(int num) throws Exception {
log.info("{} 接受到请求:num={}", Thread.currentThread().getName(), num);
TimeUnit.HOURS.sleep(1);
}
}
项目中的 application.properties 文件也是空的:
这样,一个“未进行任何特殊配置”的 SpringBoot 不就有了吗?
基于这个 Demo,前面的面试题就要变成了:我短时间内不断的调用这个 Demo 的 getTest 方法,最多能调用多少次?
问题是不是又变得更加简单了一点?
那么前面这个“短时间内不断的调用”,用代码怎么表示呢?
很简单,就是在循环中不断的进行接口调用就行了。
public class MainTest {
public static void main(String[] args) {
for (int i = 0; i < 1000; i++) {
int finalI = i;
new Thread(() -> {
HttpUtil.get("127.0.0.1:8080/getTest?num=" + finalI);
}).start();
}
//阻塞主线程
Thread.yield();
}
}
当然了,这个地方你用一些压测工具,比如 jmeter 啥的,会显得逼格更高,更专业。我这里就偷个懒,直接上代码了。
答案
经过前面的准备工作,Demo 和测试代码都就绪了。
接下来就是先把 Demo 跑起来:
然后跑一把 MainTest。
当 MainTest 跑起来之后,Demo 这边就会快速的、大量的输出这样的日志:
也就是我前面 getTest 方法中写的日志:
好,现在我们回到这个问题:
我短时间内不断的调用这个 Demo 的 getTest 方法,最多能调用多少次?
来,请你告诉我怎么得到这个问题的答案?
我这里就是一个大力出奇迹,直接统计“接受到请求”关键字在日志中出现的次数就行了:
很显然,答案就是:
所以,当面试官问你:一个 SpringBoot 项目能同时处理多少请求?
你装作仔细思考之后,笃定的说:200 次。
面试官微微点头,并等着你继续说下去。
你也暗自欢喜,幸好看了歪歪歪师傅的文章,背了个答案。然后等着面试官继续问其他问题。
气氛突然就尴尬了起来。
接着,你就回家等通知了。
200 次,这个回答是对的,但是你只说 200 次,这个回答就显得有点尬了。
重要的是,这个值是怎么来的?
所以,下面这一部分,你也要背下来。
怎么来的?
在开始探索怎么来的之前,我先问你一个问题,这个 200 个线程,是谁的线程,或者说是谁在管理这个线程?
是 SpringBoot 吗?
肯定不是,SpringBoot 并不是一个 web 容器。
应该是 Tomcat 在管理这 200 个线程。
这一点,我们通过线程 Dump 也能进行验证:
通过线程 Dump 文件,我们可以知道,大量的线程都在 sleep 状态。而点击这些线程,查看其堆栈消息,可以看到 Tomcat、threads、ThreadPoolExecutor 等关键字:
at org.apache.Tomcat.util.net.NioEndpoint$SocketProcessor.doRun(NioEndpoint.java:1791)
at org.apache.Tomcat.util.net.SocketProcessorBase.run(SocketProcessorBase.java:52)
at org.apache.Tomcat.util.threads.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1191)
at org.apache.Tomcat.util.threads.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:659)
at org.apache.Tomcat.util.threads.TaskThread$WrappingRunnable.run(TaskThread.java:61)
基于“短时间内有 200 个请求被立马处理的”这个现象,结合你背的滚瓜烂熟的、非常扎实的线程池知识,你先大胆的猜一个:Tomcat 默认核心线程数是 200。
接下来,我们就是要去源码里面验证这个猜测是否正确了。
我之前分享过阅读源码的方式,《我试图通过这篇文章,教会你一种阅读源码的方式。》,其中最重要的一条就是打一个有效的断点,然后基于断点处的调用栈去定位源码。
这里我再教你一个不用打断点也能获取到调用栈的方法。
在前面已经展示过了,就是线程 Dump。
右边就是一个线程完整的调用栈:
从这个调用栈中,由于我们要找的是 Tomcat 线程池相关的源码,所以第一次出现相关关键字的地方就是这一行:
org.apache.Tomcat.util.threads.ThreadPoolExecutor.Worker#run
然后我们在这一行打上断点。
重启项目,开始调试。
进入 runWorker 之后,这部分代码看起来就非常眼熟了:
简直和 JDK 里面的线程池源码一模一样。
如果你熟悉 JDK 线程池源码的话,调试 Tomcat 的线程池,那个感觉,就像是回家一样。
如果你不熟悉的话,我建议你尽快去熟悉熟悉。
随着断点往下走,在 getTask 方法里面,可以看到关于线程池的几个关键参数:
org.apache.Tomcat.util.threads.ThreadPoolExecutor#getTask
corePoolSize,核心线程数,值为 10。
maximumPoolSize,最大线程数,值为 200。
而且基于 maximumPoolSize 这个参数,你往前翻代码,会发现这个默认值就是 200:
好,到这里,你发现你之前猜测的“Tomcat 默认核心线程数是 200”是不对的。
但是你一点也不慌,再次结合你背的滚瓜烂熟的、非常扎实的线程池知识。
并在心里又默念了一次:当线程池接受到任务之后,先启用核心线程数,再使用队列长度,最后启用最大线程数。
因为我们前面验证了,Tomcat 可以同时间处理 200 个请求,而它的线程池核心线程数只有 10,最大线程数是 200。
这说明,我前面这个测试用例,把队列给塞满了,从而导致 Tomcat 线程池启用了最大线程数:
嗯,一定是这样的!
那么,现在的关键问题就是:Tomcat 线程池默认的队列长度是多少呢?
在当前的这个 Debug 模式下,队列长度可以通过 Alt+F8 进行查看:
wc,这个值是 Integer.MAX_VALUE,这么大?
我一共也才 1000 个任务,不可能被占满啊?
一个线程池:
-
核心线程数,值为 10。 -
最大线程数,值为 200。 -
队列长度,值为 Integer.MAX_VALUE。
1000 个比较耗时的任务过来之后,应该是只有 10 个线程在工作,然后剩下的 990 个进队列才对啊?
难道我八股文背错了?
这个时候不要慌,嗦根辣条冷静一下。
目前已知的是核心线程数,值为 10。这 10 个线程的工作流程是符合我们认知的。
但是第 11 个任务过来的时候,本应该进入队列去排队。
现在看起来,是直接启用最大线程数了。
所以,我们先把测试用例修改一下:
那么问题就来了:最后一个请求到底是怎么提交到线程池里面的?
前面说了,Tomcat 的线程池源码和 JDK 的基本一样。
往线程池里面提交任务的时候,会执行 execute 这个方法:
org.apache.Tomcat.util.threads.ThreadPoolExecutor#execute(java.lang.Runnable)
对于 Tomcat 它会调用到 executeInternal 这个方法:
org.apache.Tomcat.util.threads.ThreadPoolExecutor#executeInternal
这个方法里面,标号为 ① 的地方,就是判断当前工作线程数是否小于核心线程数,小于则直接调用 addWorker 方法,创建线程。
标号为 ② 的地方主要是调用了 offer 方法,看看队列里面是否还能继续添加任务。
如果不能继续添加,说明队列满了,则来到标号为 ③ 的地方,看看是否能执行 addWorker 方法,创建非核心线程,即启用最大线程数。
把这个逻辑捋顺之后,接下来我们应该去看哪部分的代码,就很清晰了。
主要就是去看 workQueue.offer(command) 这个逻辑。
如果返回 true 则表示加入到队列,返回 false 则表示启用最大线程数嘛。
这个 workQueue 是 TaskQueue,看起来一点也不眼熟:
当然不眼熟了,因为这个是 Tomcat 自己基于 LinkedBlockingQueue 搞的一个队列。
问题的答案就藏在 TaskQueue 的 offer 方法里面。
所以我重点带你盘一下这个 offer 方法:
org.apache.Tomcat.util.threads.TaskQueue#offer
标号为 ① 的地方,判断了 parent 是否为 null,如果是则直接调用父类的 offer 方法。说明要启用这个逻辑,我们的 parent 不能为 null。
那么这个 parent 是什么玩意,从哪里来的呢?
parent 就是 Tomcat 线程池,通过其 set 方法可以知道,是在线程池完成初始化之后,进行了赋值。
也就是说,你可以理解为,在 Tomcat 的场景下,parent 不会为空。
标号为 ② 的地方,调用了 getPoolSizeNoLock 方法:
这个方法是获取当前线程池中有多个线程。
所以如果这个表达式为 true:
parent.getPoolSizeNoLock() == parent.getMaximumPoolSize()
就表明当前线程池的线程数已经是配置的最大线程数了,那就调用 offer 方法,把当前请求放到到队列里面去。
标号为 ③ 的地方,是判断已经提交到线程池里面待执行或者正在执行的任务个数,是否比当前线程池的线程数还少。
如果是,则说明当前线程池有空闲线程可以执行任务,则把任务放到队列里面去,就会被空闲线程给取走执行。
然后,关键的来了,标号为 ④ 的地方。
如果当前线程池的线程数比线程池配置的最大线程数还少,则返回 false。
前面说了,offer 方法返回 false,会出现什么情况?
是不是直接开始到上图中标号为 ③ 的地方,去尝试添加非核心线程了?
也就是启用最大线程数这个配置了。
所以,朋友们,这个是什么情况?
这个情况确实就和我们背的线程池的八股文不一样了啊。
JDK 的线程池,是先使用核心线程数配置,接着使用队列长度,最后再使用最大线程配置。
Tomcat 的线程池,就是先使用核心线程数配置,再使用最大线程配置,最后才使用队列长度。
所以,以后当面试官给你说:我们聊聊线程池的工作机制吧?
你就先追问一句:你是说的 JDK 的线程池呢还是 Tomcat 的线程池呢,因为这两个在运行机制上有一点差异。
然后,你就看他的表情。
如果透露出一丝丝迟疑,然后轻描淡写的说一句:那就对比着说一下吧。
那么恭喜你,在这个题目上开始掌握了一点主动权。
最后,为了让你更加深刻的理解到 Tomcat 线程池和 JDK 线程池的不一样,我给你搞一个直接复制过去就能运行的代码。
当你把 taskqueue.setParent(executor) 这行代码注释掉的时候,它的运行机制就是 JDK 的线程池。
当存在这行代码的时候,它的运行机制就变成了 Tomcat 的线程池。
玩去吧。
import org.apache.tomcat.util.threads.TaskQueue;
import org.apache.tomcat.util.threads.TaskThreadFactory;
import org.apache.tomcat.util.threads.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
public class TomcatThreadPoolExecutorTest {
public static void main(String[] args) throws InterruptedException {
String namePrefix = "歪歪歪-exec-";
boolean daemon = true;
TaskQueue taskqueue = new TaskQueue(300);
TaskThreadFactory tf = new TaskThreadFactory(namePrefix, daemon, Thread.NORM_PRIORITY);
ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
150, 60000, TimeUnit.MILLISECONDS, taskqueue, tf);
taskqueue.setParent(executor);
for (int i = 0; i < 300; i++) {
try {
executor.execute(() -> {
logStatus(executor, "创建任务");
try {
TimeUnit.SECONDS.sleep(2);
} catch (InterruptedException e) {
e.printStackTrace();
}
});
} catch (Exception e) {
e.printStackTrace();
}
}
Thread.currentThread().join();
}
private static void logStatus(ThreadPoolExecutor executor, String name) {
TaskQueue queue = (TaskQueue) executor.getQueue();
System.out.println(Thread.currentThread().getName() + "-" + name + "-:" +
"核心线程数:" + executor.getCorePoolSize() +
"\t活动线程数:" + executor.getActiveCount() +
"\t最大线程数:" + executor.getMaximumPoolSize() +
"\t总任务数:" + executor.getTaskCount() +
"\t当前排队线程数:" + queue.size() +
"\t队列剩余大小:" + queue.remainingCapacity());
}
}
等等
如果你之前确实没了解过 Tomcat 线程池的工作机制,那么看到这里的时候也许你会觉得确实是有一点点收获。
但是,注意我要说但是了。
还记得最开始的时候面试官的问题吗?
面试官的原问题就是:一个 SpringBoot 项目能同时处理多少请求?
那么请问,前面我讲了这么大一坨 Tomcat 线程池运行原理,这个回答,和这个问题匹配吗?
是的,除了最开始提出的 200 这个数值之外,并不匹配,甚至在面试官的眼里完全是答非所问了。
所以,为了把这两个“并不匹配”的东西比较顺畅的链接起来,你必须要先回答面试官的问题,然后再开始扩展。
比如这样答:一个未进行任何特殊配置,全部采用默认设置的 SpringBoot 项目,这个项目同一时刻最多能同时处理多少请求,取决于我们使用的 web 容器,而 SpringBoot 默认使用的是 Tomcat。
Tomcat 的默认核心线程数是 10,最大线程数 200,队列长度是无限长。但是由于其运行机制和 JDK 线程池不一样,在核心线程数满了之后,会直接启用最大线程数。所以,在默认的配置下,同一时刻,可以处理 200 个请求。
在实际使用过程中,应该基于服务实际情况和服务器配置等相关消息,对该参数进行评估设置。
这个回答就算是差不多了。
但是,如果很不幸,如果你遇到了我,为了验证你是真的自己去摸索过,还是仅仅只是看了几篇文章,我可能还会追问一下:
那么其他什么都不动,如果我仅仅加入 server.tomcat.max-connections=10 这个配置呢,那么这个时候最多能处理多少个请求?
你可能就要猜了:10 个。
是的,我重新提交 1000 个任务过来,在控制台输出的确实是 10 个,
那么 max-connections 这个参数它怎么也能控制请求个数呢?
为什么在前面的分析过程中我们并没有注意到这个参数呢?
首先我们看一下它的默认值:
因为它的默认值是 8192,比最大线程数 200 大,这个参数并没有限制到我们,所以我们没有关注到它。
当我们把它调整为 10 的时候,小于最大线程数 200,它就开始变成限制项了。
那么 max-connections 这个参数到底是干啥的呢?
你先自己去摸索摸索吧。
同时,还有这样的一个参数,默认是 100:
server.tomcat.accept-count=100
它又是干什么的呢?
“和连接数有关”,我只能提示到这里了,自己去摸索吧。
再等等
通过前面的分析,我们知道了,要回答“一个 SpringBoot 项目默认能处理的任务数”,这个问题,得先明确其使用的 web 容器。
那么问题又来了:SpringBoot 内置了哪些容器呢?
Tomcat、Jetty、Netty、Undertow
前面我们都是基于 Tomcat 分析的,如果我们换一个容器呢?
比如换成 Undertow,这个玩意我只是听过,没有实际使用过,它对我来说就是一个黑盒。
管它的,先换了再说。
从 Tomcat 换成 Undertow,只需要修改 Maven 依赖即可,其他什么都不需要动:
再次启动项目,从日志可以发现已经修改为了 Undertow 容器:
此时我再次执行 MainTest 方法,还是提交 1000 个请求:
从日志来看,发现只有 48 个请求被处理了。
就很懵逼,48 是怎么回事儿,怎么都不是一个整数呢,这让强迫症很难受啊。
这个时候你的想法是什么,是不是想要看看 48 这个数字到底是从哪里来的?
怎么看?
之前找 Tomcat 的 200 的时候不是才教了你的嘛,直接往 Undertow 上套就行了嘛。
打线程 Dump,然后看堆栈消息:
发现 EnhancedQueueExecutor 这个线程池,接着在这个类里面去找构建线程池时的参数。
很容易就找到了这个构造方法:
所以,在这里打上断点,重启项目。
通过 Debug 可以知道,关键参数都是从 builder 里面来的。
而 builder 里面,coreSize 和 maxSize 都是 48,队列长度是 Integer.MAX_VALUE。
所以看一下 Builder 里面的 coreSize 是怎么来的。
点过来发现 coreSize 的默认值是 16:
不要慌,再打断点,再重启项目。
然后你会在它的 setCorePoolSize 方法处停下来,而这个方法的入参就是我们要找的 48:
顺藤摸瓜,重复几次打断点、重启的动作之后,你会找到 48 是一个名为 WORKER_TASK_CORE_THREADS 的变量,是从这里来的:
而 WORKER_TASK_CORE_THREADS 这个变量设置的地方是这样的:
io.undertow.Undertow#start
而这里的 workerThreads 取值是这样的:
io.undertow.Undertow.Builder#Builder
取的是机器的 CPU 个数乘以 8。
所以我这里是 6*8=48。
哦,真相大白,原来 48 是这样来的。
没意思。
确实没意思,但是既然都已经替换为 Undertow 了,那么你去研究一下它的 NIO ByteBuffer、NIO Channel、BufferPool、XNIO Worker、IO 线程池、Worker 线程池...
然后再和 Tomcat 对比着学,
就开始有点意思了。
最后再等等
这篇文章是基于“一个 SpringBoot 项目能同时处理多少请求?”这个面试题出发的。
但是经过我们前面简单的分析,你也知道,这个问题如果在没有加一些特定的前提条件的情况下,答案是各不一样的。
比如我再给你举一个例子,还是我们的 Demo,只是使用一下 @Async 注解,其他什么都不变:
再次启动项目,发起访问,日志输出变成了这样:
同时能处理的请求,直接从 Tomcat 的默认 200 个变成了 8 个?
因为 @Async 注解对应的线程池,默认的核心线程数是 8。
之前写过这篇文章《别问了,我真的不喜欢@Async这个注解!》分析过这个注解。
所以你看,稍微一变化,答案看起来又不一样了,同时这个请求在内部流转的过程也不一样了,又是一个可以铺开谈的点。
在面试过程中也是这样的,不要急于答题,当你觉得面试官问题描述的不清楚的地方,你可以先试探性的问一下,看看能不能挖掘出一点他没有说出来的默认条件。
当“默认条件”挖掘的越多,你的回答就会更容易被面试官接受。而这个挖掘的过程,也是面试过程中一个重要的表现环节。
而且,有时候,面试官就喜欢给出这样的“模糊”的问题,因为问题越模糊,坑就越多,当面试者跳进自己挖好的坑里面的时候,就是结束一次交锋的时候;当面试者看出来自己挖好的坑,并绕过去的时候,也是结束一轮交锋的时候。
所以,不要急于答题,多想,多问。不管是对于面试者还是面试官,一个好的面试体验,一定不是没有互动的一问一答,而是一个相互拉锯的过程。