启动 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 secondsApplicationStartedEvent已启动
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://jiangyi.space/articles/2026/11/07/1793800504671.html
公众号:服务端技术精选
    评论
    0 评论
avatar

取消