Rust主进程终止时，无需unsafe安全杀死std::process::Child的方案

我通过以下代码启动了一个子进程：

let child = Command::new("./chromedriver")
    .spawn()
    .expect("Failed To Run Chromedriver");

我希望在主进程终止执行时杀死该子进程，但遇到了以下难题：

• Rust中似乎没有简便的方式注册进程退出时执行的函数，只能使用类似libc::atexit()的方法。
• 我不知道如何在Rust中给C函数指针传递参数，因此不得不使用全局变量。
• 无法直接将std::process::Child存储为未初始化的全局静态变量，若仅在文件开头声明static mut CHILD_PROCESS: std::process::Child;会触发“free static item without body”错误。

为此我实现了一个复杂的unsafe方案：

static mut CHILD_PROCESS_ID: i32 = 0;

extern "C" fn kill_child() {
    unsafe {
        let pid: libc::pid_t = CHILD_PROCESS_ID;
        libc::kill(pid, libc::SIGKILL);
    }
}

fn run_chrome_driver() {
    let child = Command::new("./chromedriver")
        .spawn()
        .expect("Failed To Run Chromedriver");
    unsafe {
        let id: i32 = child.id().try_into().unwrap();
        CHILD_PROCESS_ID = id;
        libc::atexit(kill_child);
    }
}

请问是否存在无需使用unsafe Rust的更佳实现方案？

可以利用Rust的**RAII（资源获取即初始化）**特性结合全局安全状态管理，完全避免unsafe代码，同时覆盖正常退出、panic、信号终止等多种场景：

方案1：基础RAII（覆盖正常退出与panic） #

通过自定义结构体实现Drop trait，让子进程在结构体被销毁时自动终止。结合panic钩子确保panic场景下也能触发清理逻辑：

use std::process::{Command, Child};
use std::sync::OnceLock;

// 全局安全存储子进程守卫，确保panic时也能访问
static CHILD_GUARD: OnceLock<ChildGuard> = OnceLock::new();

struct ChildGuard(Child);

impl Drop for ChildGuard {
    fn drop(&mut self) {
        // 尝试杀死子进程并等待退出，忽略错误避免清理逻辑引发新问题
        let _ = self.0.kill();
        let _ = self.0.wait();
    }
}

fn run_chrome_driver() {
    let child = Command::new("./chromedriver")
        .spawn()
        .expect("Failed To Run Chromedriver");
    
    // 将守卫存入全局OnceLock，确保全局唯一
    CHILD_GUARD.set(ChildGuard(child))
        .expect("Chromedriver already running");
}

fn main() {
    // 设置panic钩子，确保panic时全局守卫被销毁
    std::panic::set_hook(Box::new(|_| {
        let _ = CHILD_GUARD.take();
    }));

    run_chrome_driver();

    // 主程序逻辑...

    // 正常退出时，全局守卫会自动被销毁，触发子进程终止
}

方案2：结合信号处理（覆盖外部信号终止） #

如果需要处理SIGINT（Ctrl+C）、SIGTERM等外部终止信号，可以使用ctrlc crate（无需unsafe），结合RAII实现完整的清理逻辑：

use std::process::{Command, Child};
use std::sync::Arc;

struct ChildGuard(Child);

impl Drop for ChildGuard {
    fn drop(&mut self) {
        let _ = self.0.kill();
        let _ = self.0.wait();
    }
}

fn main() {
    let child = Command::new("./chromedriver")
        .spawn()
        .expect("Failed To Run Chromedriver");
    
    let guard = Arc::new(ChildGuard(child));
    let guard_clone = Arc::clone(&guard);

    // 注册信号处理函数
    ctrlc::set_handler(move || {
        // 销毁克隆的守卫，触发子进程终止
        drop(guard_clone);
        std::process::exit(0);
    }).expect("Failed to set signal handler");

    // 主程序逻辑...

    // 正常退出时自动销毁守卫
}

方案优势 #

• 完全避免unsafe代码，符合Rust安全规范
• RAII特性确保资源自动清理，无需手动管理
• 覆盖正常退出、panic、外部信号等多种进程终止场景
• 无需依赖全局可变变量，使用OnceLock或Arc实现安全的全局状态访问

内容的提问来源于stack exchange，提问作者YuhaoHanHarry