如何终止子进程？超时终止与捕获输出的Rust实现困境

问题重现 #

你编写了一个Rust程序，启动子进程后在后台线程捕获其输出，设置超时后终止子进程，但调用kill()后，读取stdout的阻塞read()并未触发错误退出，线程要等到子进程自然结束才会退出。尝试用Child::wait_with_output时，因需要用Arc<Mutex>共享子进程句柄，导致kill()和wait_with_output()的锁冲突，无法并发执行。

你的测试代码如下：

Rust 主程序 #

use std::io::Read;
use std::thread;
use std::process::{Command, Stdio};
use std::time::Duration;

fn main() {
    let mut child_handle = Command::new("/path/to/prog.sh")
            .stdout(Stdio::piped())
            .spawn()
            .expect("could not spawn program");

    println!("CHILD STARTED");

    let mut out = child_handle.stdout.take().expect("could not take stdout");

    let mut thread_handle = Some(thread::spawn(move|| {
        let mut buf = [0;65536];
        let mut all_out: Vec<u8> = Vec::new();

        loop {
            println!("reading max 65K bytes");
            match out.read(&mut buf) {
                Ok(sz) => {
                    println!("read {} bytes", sz);
                    all_out.extend_from_slice(&buf[0..sz]);
                },
                Err(e) => {
                    println!("could not read bytes: {}", e);
                    break;
                }
            }
        }
    }));

    println!("WAITING...");
    thread::sleep(Duration::from_millis(2500));

    println!("KILLING");
    child_handle.kill();
    thread_handle.take().unwrap().join();
}

测试脚本 prog.sh #

#!/bin/bash

sleep 1
echo Ready
sleep 1
echo Steady
sleep 10
echo Go

问题原因 #

1. 未处理EOF场景：当子进程被终止后，其stdout管道的写端会关闭，此时read()会返回Ok(0)（表示到达文件末尾），但你的代码仅处理了Err情况，没有判断sz == 0的EOF信号，导致线程进入无限循环，持续读取0字节却不退出。
2. wait_with_output使用误区：wait_with_output会一次性读取子进程所有输出并等待其结束，若用Arc<Mutex>包裹子进程句柄，锁的持有会导致kill()必须等待wait_with_output释放锁才能执行，造成逻辑阻塞。

解决方案 #

方案1：修复读取线程的EOF处理 #

修改读取线程逻辑，当read()返回Ok(0)时退出循环，这是管道关闭的标准信号：

use std::io::Read;
use std::thread;
use std::process::{Command, Stdio};
use std::time::Duration;

fn main() {
    let mut child_handle = Command::new("./prog.sh")
            .stdout(Stdio::piped())
            .spawn()
            .expect("could not spawn program");

    println!("CHILD STARTED");

    let mut out = child_handle.stdout.take().expect("could not take stdout");

    let thread_handle = thread::spawn(move|| {
        let mut buf = [0;65536];
        let mut all_out: Vec<u8> = Vec::new();

        loop {
            println!("reading max 65K bytes");
            match out.read(&mut buf) {
                Ok(sz) => {
                    if sz == 0 {
                        // 管道已关闭，到达EOF，退出循环
                        println!("reached EOF, exiting reader thread");
                        break;
                    }
                    println!("read {} bytes", sz);
                    all_out.extend_from_slice(&buf[0..sz]);
                },
                Err(e) => {
                    println!("could not read bytes: {}", e);
                    break;
                }
            }
        }
        // 返回捕获的输出
        String::from_utf8_lossy(&all_out).to_string()
    });

    println!("WAITING...");
    thread::sleep(Duration::from_millis(2500));

    println!("KILLING");
    // 尝试终止子进程，忽略错误（比如子进程可能已经自行结束）
    let _ = child_handle.kill();
    // 等待读取线程结束并获取输出
    let output = thread_handle.join().unwrap();
    println!("Captured output:\n{}", output);
}

方案2：使用wait_timeout替代sleep（更可靠的超时处理） #

用std::process::Child::wait_timeout直接等待子进程一段时间，超时则终止它，同时结合线程读取输出，避免不必要的等待：

use std::io::Read;
use std::thread;
use std::process::{Command, Stdio, ExitStatus};
use std::time::Duration;
use std::sync::{Arc, Mutex};

fn main() {
    let mut child = Command::new("./prog.sh")
        .stdout(Stdio::piped())
        .spawn()
        .expect("failed to spawn child");

    let stdout = child.stdout.take().expect("failed to take stdout");
    // 用Arc<Mutex>共享子进程句柄，用于读取线程检查子进程状态
    let child_arc = Arc::new(Mutex::new(child));

    // 启动读取线程
    let read_child = Arc::clone(&child_arc);
    let output_thread = thread::spawn(move || {
        let mut buf = [0; 65536];
        let mut all_out = Vec::new();
        let mut stdout = stdout;

        loop {
            match stdout.read(&mut buf) {
                Ok(sz) => {
                    if sz == 0 {
                        break;
                    }
                    all_out.extend_from_slice(&buf[0..sz]);
                }
                Err(e) => {
                    eprintln!("read error: {}", e);
                    break;
                }
            }

            // 定期检查子进程是否已终止，提前退出
            let child = read_child.lock().unwrap();
            if child.try_wait().unwrap().is_some() {
                break;
            }
        }

        String::from_utf8_lossy(&all_out).to_string()
    });

    // 等待子进程超时
    let timeout = Duration::from_millis(2500);
    let mut child = child_arc.lock().unwrap();
    let status: Option<ExitStatus> = child.wait_timeout(timeout).unwrap();

    if status.is_none() {
        // 超时，终止子进程
        println!("TIMEOUT: killing child process");
        child.kill().expect("failed to kill child");
        // 等待子进程彻底结束
        let _ = child.wait();
    }

    // 获取捕获的输出
    let output = output_thread.join().unwrap();
    println!("Captured output:\n{}", output);
}

方案3：用wait_with_output结合线程避免锁冲突 #

如果想使用wait_with_output，可以启动独立线程等待输出，主线程处理超时并终止子进程，无需锁竞争：

use std::process::{Command, Stdio, Output};
use std::thread;
use std::time::Duration;
use std::sync::{Arc, Mutex};

fn main() {
    let mut child = Command::new("./prog.sh")
        .stdout(Stdio::piped())
        .stderr(Stdio::piped())
        .spawn()
        .expect("failed to spawn child");

    let child_arc = Arc::new(Mutex::new(child));
    let child_clone = Arc::clone(&child_arc);

    // 启动线程等待子进程输出
    let output_thread = thread::spawn(move || {
        let mut child = child_clone.lock().unwrap();
        child.wait_with_output().unwrap()
    });

    // 主线程等待超时
    thread::sleep(Duration::from_millis(2500));

    // 检查线程是否已结束，未结束则终止子进程
    if !output_thread.is_finished() {
        println!("TIMEOUT: killing child");
        let mut child = child_arc.lock().unwrap();
        let _ = child.kill();
    }

    // 获取输出
    let output: Output = output_thread.join().unwrap();
    println!("Captured stdout:\n{}", String::from_utf8_lossy(&output.stdout));
    println!("Captured stderr:\n{}", String::from_utf8_lossy(&output.stderr));
}

关键要点 #

• 处理read()返回Ok(0)的EOF场景是解决线程无法退出的核心。
• wait_timeout是标准库中更专业的子进程超时等待方式，比sleep更可靠（不会在子进程提前结束时浪费等待时间）。
• 使用Arc<Mutex>共享子进程句柄时，要尽量缩短锁的持有时间，避免阻塞其他操作。

内容的提问来源于stack exchange，提问作者los vatos locos