Rust中如何安全终止进程？解决子线程h2无法终止的问题

Rust标准库没有提供强制终止线程的API（强制终止可能引发资源泄漏、锁未释放等不安全问题），因此必须采用协作式退出的方式，让线程自行检测退出条件并主动终止。针对你的场景，以下是两种可行的实现方案：

方案一：使用原子布尔值作为退出标志 #

原子布尔值是线程安全的状态标记，适合简单的退出通知场景，能在多线程间安全共享和修改。

修改后的代码 #

use std::process::{Command, Stdio, Child};
use std::thread;
use std::sync::{Arc, AtomicBool};
use std::sync::atomic::Ordering;
use std::io::{BufRead, BufReader};

fn main() {
    let mut child_handle = Command::new("some_program")
        .current_dir("/some_dir")
        .stdout(Stdio::piped())
        .stderr(Stdio::piped());

    let mut child = child_handle.spawn().expect("Cannot run child process");

    let out = child.stdout.take().expect("Cannot take stdout");
    let err = child.stderr.take().expect("Cannot take stderr");

    // 创建线程共享的退出标志，初始为false
    let should_exit = Arc::new(AtomicBool::new(false));
    let should_exit_h1 = Arc::clone(&should_exit);
    let should_exit_h2 = Arc::clone(&should_exit);

    let h1 = thread::spawn(move || {
        let mut out_reader = BufReader::new(out);
        let mut buffer = String::new();

        loop {
            match out_reader.read_line(&mut buffer) {
                Ok(0) => break, // stdout管道关闭，子进程已退出
                Ok(_) => {
                    println!("'{}'", buffer.strip_suffix('\n').unwrap_or(&buffer));
                    buffer.clear();
                }
                Err(e) => {
                    eprintln!("读取stdout失败: {}", e);
                    break;
                }
            }

            // 检查子进程状态，退出时设置标志
            if let Ok(Some(_)) = child.try_wait() {
                should_exit_h1.store(true, Ordering::SeqCst);
                break;
            }
        }
    });

    let h2 = thread::spawn(move || {
        let mut err_reader = BufReader::new(err);
        let mut buffer = String::new();

        loop {
            // 优先检查是否需要退出
            if should_exit_h2.load(Ordering::SeqCst) {
                break;
            }

            match err_reader.read_line(&mut buffer) {
                Ok(0) => break, // stderr管道关闭，子进程已退出
                Ok(_) => {
                    if !buffer.is_empty() {
                        let output = buffer.strip_suffix('\n').unwrap_or(&buffer).to_string();
                        println!("'{}'", output);
                        buffer.clear();
                    }
                }
                Err(e) => {
                    eprintln!("读取stderr失败: {}", e);
                    break;
                }
            }
        }
    });

    h1.join().unwrap();
    // 确保h2收到退出信号（覆盖h1未触发标志的情况）
    should_exit.store(true, Ordering::SeqCst);
    h2.join().unwrap();
}

方案说明 #

1. 用Arc<AtomicBool>创建线程共享的退出标志：Arc保证原子值能被多线程持有，AtomicBool保证状态修改的线程安全性。
2. h1线程检测到子进程退出时，将标志设为true。
3. h2线程每次循环都检查标志，一旦为true就立即退出。
4. 即使子进程退出后管道自动关闭导致线程自然退出，标志也能让h2更快响应终止指令。

方案二：使用通道发送退出信号 #

如果需要更灵活的线程间通信，可以用标准库的mpsc通道发送退出信号。

修改后的代码 #

use std::process::{Command, Stdio, Child};
use std::thread;
use std::sync::mpsc;
use std::io::{BufRead, BufReader};

fn main() {
    let mut child_handle = Command::new("some_program")
        .current_dir("/some_dir")
        .stdout(Stdio::piped())
        .stderr(Stdio::piped());

    let mut child = child_handle.spawn().expect("Cannot run child process");

    let out = child.stdout.take().expect("Cannot take stdout");
    let err = child.stderr.take().expect("Cannot take stderr");

    // 创建退出信号通道
    let (exit_tx, exit_rx) = mpsc::channel();

    let h1 = thread::spawn(move || {
        let mut out_reader = BufReader::new(out);
        let mut buffer = String::new();

        loop {
            match out_reader.read_line(&mut buffer) {
                Ok(0) => break,
                Ok(_) => {
                    println!("'{}'", buffer.strip_suffix('\n').unwrap_or(&buffer));
                    buffer.clear();
                }
                Err(e) => {
                    eprintln!("读取stdout失败: {}", e);
                    break;
                }
            }

            if let Ok(Some(_)) = child.try_wait() {
                let _ = exit_tx.send(()); // 发送退出信号
                break;
            }
        }
    });

    let h2 = thread::spawn(move || {
        let mut err_reader = BufReader::new(err);
        let mut buffer = String::new();

        loop {
            // 非阻塞检查退出信号
            if exit_rx.try_recv().is_ok() {
                break;
            }

            match err_reader.read_line(&mut buffer) {
                Ok(0) => break,
                Ok(_) => {
                    if !buffer.is_empty() {
                        let output = buffer.strip_suffix('\n').unwrap_or(&buffer).to_string();
                        println!("'{}'", output);
                        buffer.clear();
                    }
                }
                Err(e) => {
                    eprintln!("读取stderr失败: {}", e);
                    break;
                }
            }
        }
    });

    h1.join().unwrap();
    // 确保发送退出信号，覆盖h1未触发的情况
    let _ = exit_tx.send(());
    h2.join().unwrap();
}

方案说明 #

1. mpsc::channel()创建单生产者多消费者通道，h1作为生产者发送退出信号，h2作为消费者接收。
2. h2用try_recv()非阻塞检查通道，避免阻塞在读取stderr时错过退出信号。
3. 即使h1已经发送过信号，主线程最后再次发送信号，确保h2能收到终止指令。

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