启动 42 秒,探针 30 秒超时,内嵌 Tomcat 到底在哪一行起来的
引言
一个服务上线后一直 CrashLoopBackOff。K8s 的 liveness 探针配的是 30 秒超时,而这个服务冷启动要 42 秒——每次刚过探针阈值就被杀掉,重启,再被杀。
但奇怪的是,运维截到的日志里,Started Application in 41.8 seconds 之前,Tomcat 已经打出了 Tomcat started on port(s): 8080;健康检查在那个瞬间就是 UP 状态。也就是说:容器已经对外服务了,但初始化还没做完。
顺着这个问题读源码才发现,内嵌 Tomcat 的启动时机比大多数人以为的早得多——它发生在 refresh() 阶段,早于 CommandLineRunner 和 ApplicationRunner。我们那个"预热本地缓存"的逻辑正好写在 Runner 里,于是流量进来时缓存还是空的。
这篇从 main 方法一路跟到 Tomcat.start(),把七个阶段和那一行关键代码找出来。结论先给:Tomcat 在 refreshContext 里启动,Runner 在它之后执行;任何"必须先于流量完成"的初始化,都不能放在 Runner 里。
一、入口:main 里其实只做了一件事
public static void main(String[] args) {
SpringApplication.run(MyApplication.class, args);
}
静态方法内部先 new SpringApplication(primarySources),再 .run(args)。构造阶段做的是"判断这是个什么应用":
WebApplicationType.deduceFromClasspath()看类路径里有没有DispatcherServlet、ServletContainer,有就是 SERVLET,只有 WebFlux 就是 REACTIVE,都没有就是 NONE;- 用
SpringFactoriesLoader加载ApplicationContextInitializer和ApplicationListener(spring.factories/AutoConfiguration.imports那套机制); deduceMainApplicationClass()从当前调用栈里找带main方法的类,用来打印 banner 和推断包扫描范围。
这一步决定了后面创建哪种 ApplicationContext:SERVLET 类型创建的是 AnnotationConfigServletWebServerApplicationContext,它才具备"启动 Web 容器"的能力。NONE 类型创建的是普通 AnnotationConfigApplicationContext,跑完 run() 就退出——命令行工具就是这么来的。
deduceMainApplicationClass() 的实现是从当前线程的调用栈里找方法名为 main 的第一帧,取它的类名。这个"猜"出来的类只用于打印 banner 和推断启动类,猜错也不会让启动失败,但会让 banner 旁边的版本信息位置变得很奇怪。
二、run() 的七个阶段
主干代码去掉异常处理后,大致是这样:
public ConfigurableApplicationContext run(String... args) {
listeners.starting(); // ①
ConfigurableEnvironment env = prepareEnvironment(listeners, args); // ②
Banner banner = printBanner(env); // ③
context = createApplicationContext(); // ④
prepareContext(context, env, listeners, args, banner); // ⑤
refreshContext(context); // ⑥ ← Tomcat 在这里启动
afterRefresh(context, args);
listeners.started(context, timeTakenToStartup); // ⑦
callRunners(context, args); // ⑧ ← Runner 在这里执行
listeners.running(context);
return context;
}
八个动作对应七个阶段(③只是打印 banner),每个阶段都对应一个事件:
| 阶段 | 关键动作 | 发布的事件 | Tomcat 状态 |
|---|---|---|---|
starting | 记录启动时间、加载监听器 | ApplicationStartingEvent | 未创建 |
prepareEnvironment | 加载 application.yml、环境变量、命令行参数 | ApplicationEnvironmentPreparedEvent | 未创建 |
createApplicationContext | 按 Web 类型创建容器 | 无 | 未创建 |
prepareContext | 注册主类、执行 Initializer、加载 Bean 定义 | ApplicationContextInitializedEvent / ApplicationPreparedEvent | 未创建 |
refreshContext | 刷新容器,创建并启动 Web 服务器 | ContextRefreshedEvent | 已启动、可接流量 |
listeners.started | 打印 Started ... in x seconds | ApplicationStartedEvent | 已启动 |
callRunners | 执行 CommandLineRunner / ApplicationRunner | 无 | 已启动 |
表里最扎眼的是最后两行:Tomcat 在 refreshContext 就起来了,而 Runner 要等到后面才跑。 这中间的任何初始化,都在"服务已经对外"的前提下执行。
2.1 prepareEnvironment:配置到底从哪来
ConfigDataEnvironmentPostProcessor 会在 ApplicationEnvironmentPreparedEvent 时介入,按优先级加载:命令行参数 > 环境变量 > application-{profile}.yml > application.yml > 默认值。
这一步还没有任何业务 Bean,所以在这里做的只有"决定运行环境"——端口、数据源地址、日志级别都是这时候定下来的。如果你在 main 里手动 System.setProperty,要注意它和配置文件的优先级关系,命令行参数永远最高。
EnvironmentPostProcessor 也可以在这一步挂进来,用来读取额外配置源(比如 Nacos、配置中心)。它的执行时机早于任何 Bean 创建,所以只能拿 Environment,拿不到 ApplicationContext——很多人想在 EnvironmentPostProcessor 里注入一个 Service,结果拿到的是空指针,原因就在这里。
2.2 createApplicationContext:选错类型就没有 Web 容器
webApplicationType 决定了 ApplicationContext 的实现类。很多人引入 spring-boot-starter-webflux 又引入了 starter-web,类路径里两者都有,deduceFromClasspath 判定为 SERVLET——WebFlux 的 WebHandler 不会被当成主容器,最终跑的是 Tomcat。这类"依赖冲突导致容器类型变化"的问题,只有在这一步才看得出来。
2.3 prepareContext:Bean 定义在这里注册
load(context, sources) 把主类注册成一个 Bean,applyInitializers 执行所有 ApplicationContextInitializer,listeners.contextLoaded 触发 EnvironmentPostProcessor 之后的最后一轮加工。
注意:这时候 Bean 只是"定义"被注册,还没有实例化。单例 Bean 的创建发生在下一步的 refresh 里。所以 @PostConstruct 的执行时机也在 refresh 阶段——和 Tomcat 启动是同一阶段,顺序取决于 Bean 的依赖关系。
applyInitializers 里常见的坑是"在 Initializer 里 getBean":此时容器还没 refresh,单例都没实例化,直接取 Bean 会触发提前创建,某些 BeanPostProcessor 还没注册,代理类可能不会生效。Initializer 只适合改容器配置(比如注册 PropertySource),不适合取业务 Bean。
2.4 refreshContext:所有 Bean 实例化 + Web 容器启动
refreshContext 最终调到 AbstractApplicationContext#refresh(),它做两件事:prepareRefresh + finishBeanFactoryInitialization(实例化所有非懒加载单例)+ finishRefresh。
对 Servlet 应用,finishRefresh 被 ServletWebServerApplicationContext 重写了,Web 容器的创建和启动就发生在这里。下一章展开。
refresh() 内部有十几个步骤,真正影响启动耗时的通常是三个:invokeBeanFactoryPostProcessors(解析 @Configuration、条件装配、自动配置类筛选,类越多越慢)、registerBeanPostProcessors、finishBeanFactoryInitialization(实例化所有单例,@PostConstruct 都在这里跑)。启动慢的服务,先看这三个阶段的耗时,而不是先怀疑 Tomcat。
2.5 callRunners:最后才轮到 Runner
按 Ordered 排序后依次执行所有 CommandLineRunner 和 ApplicationRunner。这是业务侧最常用的"启动后做点什么"的入口——但也正因为它在 Tomcat 启动之后,放错了地方就会造成"服务已接流量、初始化没完成"。
三、Tomcat 到底在哪一行启动
3.1 onRefresh:容器刷新时创建 Web 服务器
protected void onRefresh() {
super.onRefresh();
try {
createWebServer(); // 关键入口
} catch (Throwable ex) {
throw new ApplicationContextException("Unable to start web server", ex);
}
}
private void createWebServer() {
ServletWebServerFactory factory = getWebServerFactory(); // 默认 TomcatServletWebServerFactory
this.webServer = factory.getWebServer(getSelfInitializer());
}
getWebServerFactory() 是从容器里找 ServletWebServerFactory 类型的 Bean。换成 Jetty 或 Undertow,只是这个 Bean 的实现类变了,上层流程一行都不用改——这是 Spring Boot "可替换容器"设计的落点。
getSelfInitializer() 返回的是一个 ServletContextInitializer,负责把 Servlet、Filter、Listener 注册进 Tomcat。DispatcherServlet 就是在这里通过 DispatcherServletRegistrationBean 挂上去的——所以"Spring MVC 的入口被注册到 Tomcat"这件事,发生在 Web 服务器创建之后、refresh 结束之前。
3.2 TomcatWebServer 的构造:端口递增与 await 线程
TomcatWebServer(Tomcat tomcat, boolean autoStart, Shutdown shutdown) {
this.tomcat = tomcat;
initialize(); // 里面调 tomcat.start()
if (autoStart) {
startDaemonAwaitThread(); // 非 daemon 线程,防止主线程退出后容器停止
}
}
private void initialize() {
this.tomcat.start(); // ← 真正监听端口的这一行
...
}
所以"Tomcat 启动"这件事,本质是 refresh() 里的 createWebServer() → getWebServer() → TomcatWebServer 构造 → tomcat.start()。整个过程埋在 refreshContext 这一行调用链里,日志里的 Tomcat started on port(s) 就是 tomcat.start() 之后的输出。
startDaemonAwaitThread() 起的是一个非 daemon 线程,作用是让 JVM 不会因为主线程跑完就退出。这也是为什么 Spring Boot 服务在 IDE 里 main 方法执行完后进程还活着——真正维持生命周期的是这个 await 线程,不是 run() 的返回值。理解这一点,排查"服务启动后自己退出了"就多了一个方向:检查这个线程是不是被异常打断了。
顺带说一个排查时有用的小细节:端口被占用时 Spring Boot 不会直接失败,TomcatWebServer 会把端口 +1 重试,直到找到可用端口(3.x 里由 getValidPort 相关逻辑处理)。所以看到"端口莫名变成 8081",先查是谁占了 8080,而不是怀疑配置没生效。
3.3 started 与 running 之间那段"危险窗口"
listeners.started 打印 Started Application in x seconds 时,Tomcat 已经在接流量了;callRunners 才在它之后执行。
这就解释了开头那次 CrashLoop:预热在 Runner 里,Tomcat 先起来了,探针立刻通过,流量进来时缓存是空的,报错、探针失败、重启。
更麻烦的是这个窗口里报的错误看起来像"业务 Bug":缓存未命中、表不存在、连接池未初始化,没有一条会指向"启动顺序"。我们最后是靠日志时间戳排出来的——把 Tomcat started 和第一条业务报错的时间对齐,才发现中间隔了 11 秒。
四、为什么非要放在 refresh 阶段
一个自然的疑问是:为什么不先把所有初始化做完,再启动 Tomcat?
因为 Spring Boot 的启动是由容器生命周期驱动的,而不是由代码顺序驱动的。refresh() 是 Spring 容器"所有单例 Bean 就绪"的唯一时点,finishRefresh 之后容器才算"准备好了"。Web 容器作为容器的一部分,只能在容器刷新完成时启动——否则它可能拿到还没实例化的 Bean。
这也解释了事件顺序的设计:ContextRefreshedEvent(Spring 原生)先于 ServletWebServerInitializedEvent(Boot 扩展),ApplicationStartedEvent 又在两者之后。每一个事件都精确对应"容器到了哪一步",而不是"代码跑到了哪一行"。
对我们最有用的一点:判断"初始化该放哪",不看代码顺序,看这个初始化依赖什么、被谁依赖。依赖 Bean 就绪、且必须先于流量完成,就放在 SmartLifecycle 的 start() 或者 ApplicationListener 处理 ContextRefreshedEvent 里;只是"启动后打个日志、清个临时表",放 Runner 才合适。
顺带解释一个常被问到的现象:为什么 @PostConstruct 里调用 FeignClient 有时会失败?因为 @PostConstruct 在 finishBeanFactoryInitialization 阶段执行,而 Web 服务器是 finishRefresh 才启动的——如果那个客户端依赖"端口已监听"(比如自己调自己的健康检查),时机就不对。依赖顺序问题,在启动流程里都能找到答案。
五、三条能带走的实践
第一,需要先于流量完成的初始化,放 SmartLifecycle。实现 SmartLifecycle 并把 getPhase() 设成较小的值,它会在容器刷新阶段、Web 服务器启动之前完成。这是官方推荐的位置,也比 Runner 精确。
第二,实在要放 Runner,就加一道"未就绪"闸门。让 /actuator/health 在预热完成前返回 OUT_OF_SERVICE(ApplicationAvailability 的 ReadinessState),探针就不会过早放流量进来。liveness 管的是"活着",readiness 管的是"能干活",两个探针别混用。
第三,拿启动耗时用 ApplicationStartup。BufferingApplicationStartup 会记录每个阶段的耗时,比看总耗时更容易定位到那一步——我们的 42 秒里,有 31 秒花在 @PostConstruct 里的全量缓存预热。
用起来不复杂:在 main 里 new SpringApplicationBuilder(App.class).applicationStartup(new BufferingApplicationStartup(2048)).run(args),再打开 /actuator/startup 端点,就能看到每个 StartupStep 的耗时和父子关系。这比在代码里到处打时间戳精确得多,因为它记录的是框架自己的阶段边界,不受日志缓冲和时钟误差影响。
避坑清单:
- Tomcat 在
refreshContext启动,早于callRunners,Runner 里的初始化不保证先于流量。 @PostConstruct与 Tomcat 启动在同一阶段,执行顺序由 Bean 依赖决定,不要假设。WebApplicationType由类路径推断,同时引入web和webflux会得到 Tomcat。- 端口 +1 重试是正常行为,端口号变了先查占用。
liveness与readiness别混用,启动慢的服务要靠 readiness 挡流量,而不是把 liveness 阈值调大。
收尾
启动流程真正的分界线不是"代码写到哪",而是"容器刷新到了哪"——Tomcat 在
refresh里起来,Runner 在后面跑,中间那段窗口就是所有"服务已上线但没准备好"问题的来源。
你们的预热逻辑现在放在 @PostConstruct、ApplicationRunner 还是 SmartLifecycle?有没有踩过探针过早放流量进来的坑?
关注我,每周拆一个真实生产故障。
标题:启动 42 秒,探针 30 秒超时,内嵌 Tomcat 到底在哪一行起来的
作者:jiangyi
地址:http://www.jiangyi.space/articles/2026/11/07/1793800504671.html
公众号:服务端技术精选
- 引言
- 一、入口:main 里其实只做了一件事
- 二、run() 的七个阶段
- 2.1 prepareEnvironment:配置到底从哪来
- 2.2 createApplicationContext:选错类型就没有 Web 容器
- 2.3 prepareContext:Bean 定义在这里注册
- 2.4 refreshContext:所有 Bean 实例化 + Web 容器启动
- 2.5 callRunners:最后才轮到 Runner
- 三、Tomcat 到底在哪一行启动
- 3.1 onRefresh:容器刷新时创建 Web 服务器
- 3.2 TomcatWebServer 的构造:端口递增与 await 线程
- 3.3 started 与 running 之间那段"危险窗口"
- 四、为什么非要放在 refresh 阶段
- 五、三条能带走的实践
- 收尾
评论