服务器上的Java进程收到SIGTERM后,如何等待在途请求完成再退出?

发布人:A5数据发布时间:2026-11-17 14:57阅读量:1

Java进程收到 SIGTERM 时,操作系统并不知道进程里有多少个 HTTP 请求,也不会自动为请求预留完成时间。它只负责通知进程准备结束。能否等待在途请求完成,取决于 JVM 的关闭流程、Java Web 服务器的停止方式、应用是否停止接收新请求,以及 systemd、容器或编排平台给出的最后期限。

因此,“收到 SIGTERM 后等待请求完成”不是给进程加一个信号处理器就能完整实现的动作,而是一段从流量排空到进程退出的协作过程。

先界定什么是“在途请求”

在途请求通常指已经被服务端接收,并且业务处理或响应发送尚未完成的请求。例如:

  • 请求已经进入 Servlet、WebFlux 或其他 HTTP 处理器;
  • 请求正在访问数据库、缓存或其他内部服务;
  • 请求已经返回部分响应,但流式响应尚未结束;
  • 请求已经被服务器接收,正在等待工作线程处理;
  • 使用异步 Servlet、CompletableFuture 或响应式链路时,控制器方法已经返回,但 HTTP 响应仍未完成。

它不等同于“当前建立的 TCP 连接数”。

一个 HTTP keep-alive 连接可能处于空闲状态,并没有请求;一个 HTTP/2 连接则可能同时承载多个请求流。因此,优雅退出关注的是请求或流的生命周期,而不是简单等待所有 TCP 连接断开。

先界定什么是“在途请求”配图

一个完整的排空过程至少需要满足以下条件:

  1. 不再让新的请求进入业务处理流程;
  2. 已经进入处理流程的请求继续运行;
  3. 请求完成后减少活动计数或由 Web 服务器标记为完成;
  4. 等待不能无限持续,必须有明确的超时;
  5. 超时后仍未结束的请求要进入可预期的强制关闭路径。

如果只执行 executor.shutdown(),或者只在 JVM 退出时打印一条日志,并不能证明 HTTP 请求已经完成。

SIGTERM 到 Java 进程退出的工作链路

信号本身不会等待请求

在 Linux 中,下面的命令向目标进程发送可捕获的终止信号:

kill -TERM <pid>

JVM 通常会将这个信号转换为关闭流程,启动已经注册的 shutdown hook,并让应用开始释放资源。典型链路可以表示为:

SIGTERM 到 Java 进程退出的工作链路配图

systemd / Docker / Kubernetes
        |
        | SIGTERM
        v
Java 虚拟机开始关闭
        |
        | 执行 shutdown hook、关闭应用上下文
        v
Web 服务器停止接收新请求
        |
        | 已有请求继续处理
        v
请求完成,连接或请求流被关闭
        |
        v
Java 进程退出

这里最容易被忽略的是,JVM 只负责启动关闭阶段,并不理解某个线程是不是 HTTP 请求线程,也不会自动等待数据库事务、异步任务或网络响应完成。

如果 shutdown hook 直接返回,且 Web 服务器已经关闭,那么进程可能很快退出。进程退出后,所有线程、文件描述符和网络连接都会被操作系统回收,尚未完成的请求自然无法继续。

shutdown hook 是通知机制,不是完整的排空机制

Java 可以通过 Runtime.addShutdownHook 注册关闭钩子:

Runtime.getRuntime().addShutdownHook(
    new Thread(() -> {
        // 停止接收新请求
        // 等待在途请求
        // 释放资源
    }, "shutdown-hook")
);

shutdown hook 中的代码可以等待请求完成,但这段等待必须由应用自己实现,或者交给 Spring Boot、Tomcat、Jetty、Netty 等服务器的生命周期管理。

还需要注意几个事实:

  • 多个 shutdown hook 之间没有可靠的执行顺序;
  • hook 如果无限等待,JVM 也可能一直无法退出;
  • SIGKILL 无法被捕获,shutdown hook 不会执行;
  • 外部管理器的超时时间到了以后,可能直接发送 SIGKILL;
  • hook 中启动新的异步任务,不代表 JVM 会等这些任务自动完成;
  • 如果使用 -Xrs 或自定义 native 信号处理,信号行为可能与默认配置不同。

所以,正确的设计不是“收到信号后睡眠 30 秒”,而是“停止接纳新工作,并根据实际完成状态等待,最多等待 30 秒”。

停止接收新请求和等待旧请求是两个动作

优雅退出中有两个相互配合的闸门。

第一个闸门负责停止接纳新请求。它可能表现为:

  • Web 服务器停止监听新连接;
  • 负载均衡器将实例标记为 draining 或从服务池移除;
  • 应用在入口处返回 503 Service Unavailable;
  • HTTP/2 服务器发送不再接收新流的信号;
  • keep-alive 连接不再接受新的请求。

第二个闸门负责跟踪已经接纳的请求。一个请求只有在业务处理、响应提交以及必要的异步阶段都结束后,才能从活动请求集合中移除。

如果只有第一个闸门,没有等待逻辑,已有请求仍可能被强制中断。如果只有第二个闸门,没有停止新请求,排空期间会不断有新请求进入,活动数量可能始终无法降到零。

Spring Boot 应用的常见配置

对于使用 Spring Boot 内嵌 Web 服务器的应用,通常优先使用框架提供的 graceful shutdown,而不是自己编写一套请求计数器。

在支持该功能的 Spring Boot 版本中,可以使用以下配置:

server:
  shutdown: graceful

spring:
  lifecycle:
    timeout-per-shutdown-phase: 30s

这段配置表达了两个意思:

  • server.shutdown: graceful:应用关闭时,让内嵌 Web 服务器以优雅方式停止;
  • spring.lifecycle.timeout-per-shutdown-phase: 30s:为 Spring 生命周期关闭阶段设置等待上限。

在支持该机制的嵌入式服务器中,关闭流程通常会先停止接收新的请求,再等待正在处理的请求完成。超过生命周期阶段的等待时间后,关闭流程会继续向后执行。

该配置不是对所有部署方式都自动生效。需要分别确认:

  • 使用的 Spring Boot 版本是否支持 server.shutdown=graceful;
  • 应用是使用内嵌 Tomcat、Jetty、Undertow 还是响应式服务器;
  • 应用是否实际运行在外部 Tomcat 或其他独立容器中;
  • 自定义的 Web 服务器生命周期代码是否覆盖了默认关闭逻辑;
  • 是否存在异步请求、长连接或流式响应。

如果应用以 WAR 形式部署到外部 Tomcat,真正负责停止连接器和等待请求的通常是外部容器,不能只看 Spring Boot 配置。

为什么还要配置外部停止时间

Spring Boot 的应用级等待时间还要受到进程管理器的约束。例如使用 systemd 时,可以配置:

[Unit]
After=network.target

[Service]
WorkingDirectory=/opt/demo
ExecStart=/usr/bin/java -jar /opt/demo/app.jar
KillSignal=SIGTERM
TimeoutStopSec=45s

这里可以把应用的优雅关闭时间设置为 30 秒,把 systemd 的停止时间设置为 45 秒。这样应用有机会完成请求排空、线程池关闭和资源释放,systemd 还保留了一段清理余量。

可按下面的关系规划时间:

进程管理器停止时间
    >= 应用排空时间 + 资源清理时间 + 额外余量

如果 systemd 的 TimeoutStopSec 只有 10 秒,而应用配置要等待 30 秒,那么应用永远没有机会完整执行 30 秒的排空逻辑。到达 systemd 的停止期限后,进程可能被强制终止。

为什么还要配置外部停止时间配图

如果使用 shell 脚本启动 Java,脚本需要把自身替换为 Java 进程:

#!/bin/sh
exec /usr/bin/java -jar /opt/demo/app.jar

exec 可以让 Java 进程直接成为脚本对应的进程,减少信号只发给 shell、没有正确传递给 Java 的情况。

容器中也建议使用 exec 形式的入口:

ENTRYPOINT ["java", "-jar", "/app/app.jar"]

在 Kubernetes 中,还要检查 Pod 的终止宽限时间:

spec:
  terminationGracePeriodSeconds: 45

这个时间是容器终止流程允许使用的总预算。若配置了 preStop 钩子,钩子执行时间也会消耗这段预算,不能简单地把 preStop 中的等待时间当作额外时间。

此外,应用开始退出时,负载均衡器和服务发现系统也应尽快停止向该实例发送新流量。仅由 Java 进程自己等待,并不能阻止外部系统在排空过程中继续建立新请求。

Java 应用的接口服务、业务后台与数据处理,需要相应的运行资源。A5数据提供香港、美国、日本、新加坡等地的物理服务器租用,产品涵盖常规建站、AMD计算及不同存储与网络配置,可用于部署相关应用和数据服务;各地区产品按各自配置提供选择。

自定义服务器时如何实现请求排空

如果使用的是自定义 HTTP 服务器、特殊 RPC 框架,或者需要对请求生命周期进行精确控制,可以在请求入口维护一个活动请求闸门。

下面的类展示了基本机制。它不是某个具体 Web 框架的适配器,但可以说明并发关系:

import java.time.Duration;
import java.util.concurrent.locks.Condition;
import java.util.concurrent.locks.ReentrantLock;

public final class InFlightGate {
    private final ReentrantLock lock = new ReentrantLock();
    private final Condition drained = lock.newCondition();

    private int inFlight;
    private boolean stopping;

    /**
     * 尝试接纳一个请求。
     * 返回 false 表示应用已经进入停止阶段。
     */
    public boolean tryEnter() {
        lock.lock();
        try {
            if (stopping) {
                return false;
            }
            inFlight++;
            return true;
        } finally {
            lock.unlock();
        }
    }

    /**
     * 请求真正完成后调用。
     */
    public void leave() {
        lock.lock();
        try {
            if (inFlight <= 0) {
                throw new IllegalStateException("in-flight request count underflow");
            }

            inFlight--;

            if (stopping && inFlight == 0) {
                drained.signalAll();
            }
        } finally {
            lock.unlock();
        }
    }

    /**
     * 进入停止接纳新请求的状态。
     */
    public void beginStopping() {
        lock.lock();
        try {
            stopping = true;
            if (inFlight == 0) {
                drained.signalAll();
            }
        } finally {
            lock.unlock();
        }
    }

    /**
     * 等待活动请求归零,返回 false 表示超时。
     */
    public boolean awaitDrained(Duration timeout)
            throws InterruptedException {
        long nanos = timeout.toNanos();

        lock.lock();
        try {
            while (inFlight > 0) {
                if (nanos <= 0) {
                    return false;
                }
                nanos = drained.awaitNanos(nanos);
            }
            return true;
        } finally {
            lock.unlock();
        }
    }

    public int activeCount() {
        lock.lock();
        try {
            return inFlight;
        } finally {
            lock.unlock();
        }
    }
}

在同步请求处理模型中,请求入口和出口需要成对调用:

if (!gate.tryEnter()) {
    response.setStatus(503);
    response.getWriter().write("server is shutting down");
    return;
}

try {
    requestHandler.handle(request, response);
} finally {
    gate.leave();
}

finally 不能省略。业务代码抛出异常、数据库访问失败或响应写入失败时,都必须让活动计数减少,否则关闭线程可能一直等待一个已经不存在的请求。

关闭钩子可以按照以下顺序组织:

Runtime.getRuntime().addShutdownHook(
    new Thread(() -> {
        gate.beginStopping();

        // 具体方法取决于 HTTP 服务器:
        // 停止监听新连接,但不要立即中断已有请求。
        httpServer.stopAccepting();

        try {
            boolean drained = gate.awaitDrained(Duration.ofSeconds(30));

            if (!drained) {
                System.err.println(
                    "Graceful shutdown timed out, active="
                    + gate.activeCount()
                );
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
        }

        // 关闭连接器、线程池和其他资源
        httpServer.close();
    }, "shutdown-drain")
);

实际项目中,stopAccepting() 和 close() 的名称取决于使用的服务器。应区分“停止接受新请求”和“销毁服务器”这两个动作,不能一开始就调用会立即关闭已有连接的强制停止方法。

请求计数的入口必须选对位置

如果计数发生在业务方法内部,可能漏掉已经被服务器接收、但还在队列中等待的请求。如果计数发生在连接建立位置,又可能把空闲 keep-alive 连接误判为在途请求。

较合理的计数位置通常是“请求已经通过停止闸门、即将进入业务处理”的位置。此时:

  • 在停止状态之前进入的请求会被计数;
  • 停止状态之后到达的请求会被拒绝;
  • 请求完成或失败时统一调用 leave()。

但对于异步请求,简单的 try/finally 可能不够。例如 Servlet 异步处理调用 startAsync() 后,过滤器方法可能已经返回,而 HTTP 响应尚未完成。如果此时立即调用 leave(),活动计数就会提前减少。

异步场景需要使用对应框架的完成回调,例如:

  • Servlet 异步请求使用 AsyncListener 的完成事件;
  • 响应式框架使用响应流或发布链的完成信号;
  • RPC 框架使用调用结束回调;
  • 自定义 Future 使用 whenComplete 或等价回调。

如果框架已经提供经过验证的 graceful shutdown,通常不应再叠加一个不完整的自定义计数器。

为什么只关闭线程池通常不够

不少应用会在 shutdown hook 中写出类似代码:

executorService.shutdown();
executorService.awaitTermination(30, TimeUnit.SECONDS);

这只能说明某个线程池正在等待任务结束,不能自动说明 HTTP 请求已经完成,原因包括:

  • HTTP 连接器可能仍然接受新请求;
  • 请求可能在另一个线程池中执行;
  • 请求线程可能正在等待数据库或外部服务;
  • 异步响应可能由事件循环负责;
  • 工作线程结束不代表响应已经发送完毕;
  • 线程池队列中的任务可能还没有被纳入活动请求统计。

shutdown() 的作用是拒绝向该线程池提交新的任务,并允许已经提交的任务继续执行。shutdownNow() 则可能中断正在运行的任务或返回尚未开始的任务,两者都不能替代 Web 服务器的请求排空。

正确顺序通常是:

  1. 让流量入口停止接纳新请求;
  2. 让 HTTP 服务器停止接收新的连接或请求流;
  3. 拒绝应用层新任务;
  4. 等待已经接纳的请求和必要的异步阶段完成;
  5. 在有限时间内关闭线程池、连接池和其他资源;
  6. 超时后进入强制终止或失败记录路径。

用一个慢请求验证排空行为

可以用一个仅用于测试的慢接口制造明确的观察窗口:

@RestController
public class DemoController {

    @GetMapping("/demo/slow")
    public String slow() throws InterruptedException {
        Thread.sleep(8000);
        return "done";
    }
}

这个接口只是为了让请求持续 8 秒,不应作为生产代码中的等待实现。

启动应用后,在 Linux 测试环境中执行:

java -jar app.jar >app.log 2>&1 &
pid=$!

sleep 2

curl --max-time 20 -sS \
  http://127.0.0.1:8080/demo/slow \
  >response.txt &
request_pid=$!

sleep 1
ps -o pid,ppid,cmd -p "$pid"

kill -TERM "$pid"

wait "$request_pid"
request_rc=$?

wait "$pid"
process_rc=$?

printf 'request_rc=%s process_rc=%s\n' \
  "$request_rc" "$process_rc"

cat response.txt

这里的时间关系是:

用一个慢请求验证排空行为配图

  • 慢请求启动约 1 秒后发送 SIGTERM;
  • 如果优雅退出配置有效,请求通常还会继续运行约 7 秒;
  • 请求返回 done 后,活动请求数量变为零;
  • 进程随后完成关闭并退出;
  • 如果应用等待上限设置为 30 秒,正常情况下不会触发超时。

日志可以采用类似结构帮助判断:

[shutdown] signal=TERM active=1
[request] path=/demo/slow completed
[shutdown] drained active=0
[shutdown] server closed

这只是验证时可能出现的示例日志,不代表某个特定服务器的固定输出。测试重点是事件顺序,而不是日志文字本身。

观察结果更可能说明需要继续检查的内容
慢请求正常返回,随后进程退出请求排空和关闭顺序基本生效是否还有异步任务未纳入统计
发送信号后新请求返回 503,已有请求仍返回成功应用已经停止接纳新请求负载均衡器是否仍把流量发到该实例
已有请求立即连接重置或返回网关错误服务器被立即关闭,或进程被提前杀死服务器关闭模式、容器停止时间、systemd 日志
每次都在固定的外部超时时间退出应用排空时间超过了管理器预算是否有长请求、死等、连接池阻塞或 SIGKILL
进程长时间不退出hook、线程池或请求统计一直没有完成活动计数是否泄漏,关闭钩子是否无限等待

测试时应使用明确保存的 PID,避免把 kill 发给错误的 Java 进程。kill -9 不适合用于验证优雅退出,因为 SIGKILL 不给 JVM 执行 shutdown hook 的机会。

几类会改变结果的请求

长轮询、SSE 和流式响应

长轮询、Server-Sent Events、文件流和其他持续响应可能天然运行很久。如果关闭逻辑无限等待这些请求,进程就可能无法退出。

这类请求通常要定义单独的边界,例如:

  • 设置最大连接或响应持续时间;
  • 收到停止信号后不再创建新的流;
  • 允许已有流继续一小段时间;
  • 到达关闭期限时发送结束信号并关闭连接;
  • 客户端按照可重试规则重新建立连接。

不能把“等待所有流永久结束”当作通用优雅退出策略。

WebSocket 和 HTTP/2

WebSocket 不是普通的短 HTTP 请求。它通常需要发送关闭帧、等待对端确认,或者由应用定义断开策略。

HTTP/2 的一个连接上可能有多个并行请求流。关闭连接不等于所有请求都完成;服务器需要停止创建新流,并根据实现等待已有流结束。具体行为取决于服务器版本和协议栈,不能只根据 TCP 连接数判断排空是否完成。

异步业务任务

如果 HTTP 请求提交任务到消息队列或线程池后就立即返回,那么 HTTP 请求完成只表示“提交动作完成”,不表示后台任务完成。

例如:

HTTP 请求 -> 写入任务队列 -> 立即返回 202
                         |
                         v
                    后台任务继续执行

此时优雅退出至少要分别考虑:

  • 是否停止接收新的队列任务;
  • 队列中的任务是否需要等待;
  • 正在执行的任务是否可恢复;
  • 进程被强制终止后是否会重复执行;
  • 数据库写入是否具有事务性或幂等性。

HTTP 请求排空不能自动覆盖所有后台任务。对于重要任务,应使用可持久化队列、任务状态和重试机制,而不是仅依赖 Java 进程退出前的几秒等待。

数据库和外部服务调用

请求即使已经进入响应返回阶段,数据库事务或外部副作用也必须有明确的完成边界。一般应让事务提交、必要的资源释放和响应状态保持一致。

如果关闭期限到了而请求仍在等待外部服务,应用可能只能中断请求。此时客户端是否可以重试、操作是否可能已经部分成功,都应由接口的幂等性和业务事务设计决定。

什么时候可以认定优雅退出真正生效

判断一套配置是否有效,可以同时核对以下五点:

  1. SIGTERM 确实到达了 Java 进程,而不是只到达 shell 包装进程;
  2. 进入停止状态后,不再有新的请求进入业务处理;
  3. 已有请求能够在期限内完成,活动计数或服务器指标逐渐下降;
  4. 应用等待时间短于 systemd、容器或 Kubernetes 的终止宽限时间;
  5. 超时分支有明确行为,不会因为一个异常请求让 shutdown hook 永久阻塞。

如果只有 JVM shutdown hook,却没有停止新请求的动作,进程可能在等待旧请求时继续接收新请求。如果只配置了 Web 服务器 graceful shutdown,却让外部管理器更早发送 SIGKILL,应用同样无法保证请求完成。

真正决定结果的是三者之间的时间和状态协作:Java 应用负责有边界地排空,Web 服务器负责管理连接和请求生命周期,进程管理器负责给出足够的终止时间。只有这三层的关闭顺序一致,服务器上的 Java 进程收到 SIGTERM 后,才有机会在退出前完成在途请求。

本文由A5数据原创发布,转载请注明出处:https://www.a5idc.com/helpcontent/9994.html

相关推荐