Python subprocess.Popen start_new_session 怎样清理进程组

在 Linux、macOS 等 POSIX 系统上，start_new_session=True 的价值不是“自动杀掉所有子进程”，而是让 Popen 启动的任务拥有独立的会话和进程组。超时后，父进程可以拿到这个进程组的 ID，先发送 SIGTERM，宽限期后再发送 SIGKILL，最后用 communicate() 和 wait() 收尾。

官方地址：https://docs.python.org/3/library/subprocess.html

最小原则：用 start_new_session=True 建立边界，用 os.killpg() 清理整组，用再次 communicate() 和 wait() 回收状态。只调用 proc.kill()，通常只能覆盖 Popen 的那个直接子进程。

先看清 proc.kill() 为什么不够

假设 Python 启动了一个命令，命令又启动了 worker。Popen 对象的 pid 指向直接子进程，而不是这棵命令树里的每个进程。调用 proc.terminate() 或 proc.kill() 时，信号目标是这个 PID；如果直接子进程退出后 worker 仍然存在，worker 就可能继续占用端口、文件或 CPU。

因此要把问题拆成两步：第一步在启动时创建一个只属于本次任务的进程组；第二步在超时时对这个进程组发信号。没有第一步，按组杀进程就没有可靠的边界，贸然使用当前进程组还可能误伤启动器本身。

用 start_new_session 建立独立进程组

Python 官方文档说明，start_new_session=True 会让子进程在执行目标程序前调用 setsid()，而该参数只在 POSIX 平台可用。新会话的首个进程同时成为新进程组的组长，通常可以使用这个子进程的 PID 作为进程组 ID。

import subprocess

# 独立会话让本次任务拥有自己的进程组，避免把信号发给父进程所在的组。
proc = subprocess.Popen(
    ["sh", "-c", "worker-command"],
    start_new_session=True,
    stdout=subprocess.PIPE,
    stderr=subprocess.PIPE,
    text=True,
)

# POSIX 下该子进程由 setsid 创建新进程组，组 ID 通常等于 proc.pid。
pgid = proc.pid

如果你要把这段逻辑封装成长期运行的库，可以在发送信号前调用 os.getpgid(proc.pid) 读取当前组 ID，并处理进程刚好退出导致的 ProcessLookupError。示例为了突出关系，使用了 proc.pid 这个稳定且常见的组长 ID。

TimeoutExpired 后的最小清理配方

communicate(timeout=...) 超时会抛出 subprocess.TimeoutExpired，但超时本身不会替你结束进程。比较稳妥的顺序是：先捕获异常，向进程组发送 SIGTERM；等待一小段宽限时间；仍未退出时发送 SIGKILL；最后再次调用 communicate()，让 stdout、stderr 管道和进程状态回到可收尾状态。

import os
import signal
import subprocess


def _signal_group(pgid: int, sig: signal.Signals) -> None:
    # 进程可能在超时处理前自行退出，找不到组时无需把清理升级成新错误。
    try:
        os.killpg(pgid, sig)
    except ProcessLookupError:
        pass


def terminate_process_group(proc: subprocess.Popen[str], timeout: float = 10.0) -> tuple[str, int | None]:
    # 先给正常执行留出时间，成功时直接读取输出并回收进程。
    try:
        stdout, _ = proc.communicate(timeout=timeout)
        return stdout, proc.returncode
    except subprocess.TimeoutExpired:
        pass

    # start_new_session=True 时，直接子进程的 PID 通常就是新进程组 ID。
    pgid = proc.pid
    _signal_group(pgid, signal.SIGTERM)

    try:
        # 给程序清理临时文件、刷新日志和退出线程留一点时间。
        stdout, _ = proc.communicate(timeout=2.0)
    except subprocess.TimeoutExpired:
        # 宽限期仍未结束，强制终止同一进程组，避免后代继续运行。
        _signal_group(pgid, signal.SIGKILL)
        stdout, _ = proc.communicate()

    # communicate 通常已经等待了子进程；显式 wait 让收尾意图更清楚。
    proc.wait()
    return stdout, proc.returncode

这个配方的重点是“按组发信号”，而不是把 kill() 换成另一个 API。SIGTERM 给应用一个释放资源的机会，SIGKILL 只是最后的兜底；如果业务允许，宽限时间可以按任务类型配置。

为什么终止后还要再次 communicate

很多代码在捕获 TimeoutExpired 后直接发信号，然后马上读取 returncode。这有两个问题：进程可能还没有真正退出，返回码仍然是 None；如果 stdout 或 stderr 使用了 PIPE，子进程退出时管道中可能还有未读取数据。

再次调用 communicate() 可以等待进程结束并把管道剩余内容取走。若必须分别保留标准输出和错误输出，就像完整片段一样接收两个返回值，不要为了日志方便把它们混成一个字段。随后调用 wait() 是明确的最终回收点，便于读者和调用方理解生命周期已经结束。

几个容易踩到的兼容边界

• 只适用于 POSIX：start_new_session 和 os.killpg 是 POSIX 方案。Windows 应使用其进程组或 Job Object 机制，不能把这段代码原样当成跨平台实现。
• 不要把当前进程组当目标：没有独立会话时，os.getpgrp() 可能返回启动器所在的组；对它发送信号会把 Python 父进程一起置于风险中。
• 处理退出竞态：超时异常抛出后，目标可能已经退出，所以 os.killpg() 应捕获 ProcessLookupError，并继续执行回收。
• 管道要成对收尾：使用 stdout=PIPE 或 stderr=PIPE 时，终止后仍要通过 communicate() 读取，不要只等待而不处理管道。
• 区分进程组和会话：start_new_session=True 同时建立新会话和新进程组；如果你的需求只是把子进程放进已有组，Python 3.11 及以上还可以研究 process_group 参数，但它不是这里的独立清理边界。

把配方收进一个可调用函数

在业务代码中，建议让启动参数和清理动作成对出现：创建 Popen 时固定 start_new_session=True，异常分支只接受这个对象的组 ID，成功和失败都从同一个收尾函数返回输出与退出码。

def run_command(command: list[str], timeout: float = 10.0) -> tuple[int, str, str]:
    # POSIX 下为每次任务建立独立进程组，后续只清理本次命令树。
    proc = subprocess.Popen(
        command,
        start_new_session=True,
        stdout=subprocess.PIPE,
        stderr=subprocess.PIPE,
        text=True,
    )

    try:
        # 正常路径和超时路径都通过 communicate 读取完整管道。
        stdout, stderr = proc.communicate(timeout=timeout)
    except subprocess.TimeoutExpired:
        # 先温和终止整组，避免只杀掉直接子进程。
        _signal_group(proc.pid, signal.SIGTERM)
        try:
            stdout, stderr = proc.communicate(timeout=2.0)
        except subprocess.TimeoutExpired:
            # 只有宽限期无效时才升级为强制终止。
            _signal_group(proc.pid, signal.SIGKILL)
            stdout, stderr = proc.communicate()
    finally:
        # 无论命令怎样结束，都把 Popen 的回收动作落到底。
        proc.wait()

    return proc.returncode, stdout, stderr

若要把信号发送和输出读取做得更复杂，例如区分组内不同退出码、记录超时原因或设置多级宽限期，可以在这个函数外围增加状态字段，但不要改变“独立组—按组终止—communicate—wait”的基本顺序。

总结

Python 使用 subprocess.Popen 清理进程组，关键不在超时后多调用一次 kill()，而在启动时先用 start_new_session=True 建立可定位的边界。超时后以 os.killpg() 对组发送 SIGTERM，等待宽限期后再用 SIGKILL，最后通过 communicate() 和 wait() 处理管道与回收状态。这套写法适合 POSIX 任务执行器、构建脚本和命令包装器；跨到 Windows 时，应改用平台对应的进程树管理机制。

相关问题

• start_new_session=True 会不会自动杀掉子进程？不会，它只建立独立会话和进程组；终止动作仍需要由父进程按组发送信号。
• 为什么不只调用 proc.wait(timeout=...)？wait 只能等待直接子进程，超时后仍需决定怎样处理进程组和管道。
• SIGTERM 后还要 SIGKILL 吗？不是必需，但如果任务无响应或后代仍在运行，应保留有限宽限期后的强制兜底。
• Windows 能直接使用 os.killpg 吗？不能把 POSIX 进程组方案直接照搬；Windows 需要使用对应的进程组事件或 Job Object 设计。