Struct std::process::Child

pub struct Child {
    pub stdin: Option<ChildStdin>,
    pub stdout: Option<ChildStdout>,
    pub stderr: Option<ChildStderr>,
    // some fields omitted
}

表示正在运行或退出的子进程。

该结构体用于表示和管理子进程。 子进程是通过 Command 结构体创建的，该子进程配置了生成进程，并且可以使用生成器样式的接口本身来创建子进程。

子进程没有 Drop 的实现，所以如果您不确保 Child 已经退出，那么它会继续运行，即使在子进程的 Child 句柄已经离开作用域之后。

调用 wait (或其他环绕它的函数) 将使父进程等待直到子进程实际退出后再继续。

Warning

在某些系统上，操作系统释放资源必须调用 wait 或类似方法。终止但尚未等待的进程仍然是 “zombie”。 留下太多的僵尸可能会耗尽整个资源 (例如，进程 ID)。

标准库不会自动等待子进程 (即使 Child 被丢弃也不会)，这取决于应用程序开发人员。 因此，在长时间运行的应用程序中，不建议先丢弃 Child 句柄而不先等待它们。

Examples

use std::process::Command;

let mut child = Command::new("/bin/cat")
                        .arg("file.txt")
                        .spawn()
                        .expect("failed to execute child");

let ecode = child.wait()
                 .expect("failed to wait on child");

assert!(ecode.success());

Fields

stdin: Option<ChildStdin>

写入子节点标准输入 (stdin) 的句柄 (如果已捕获)。 为避免部分移动 child 并因此阻止您自己在使用 stdin 时在 child 上调用函数，您可能会发现它很有用:

let stdin = child.stdin.take().unwrap();

stdout: Option<ChildStdout>

从子节点的标准输出 (stdout) 读取的句柄 (如果已捕获)。 您可能会发现这样做很有帮助

let stdout = child.stdout.take().unwrap();

为了避免部分移动 child，从而在使用 stdout 时阻止自己在 child 上调用函数。

stderr: Option<ChildStderr>

从子节点的标准错误 (stderr) 读取的句柄 (如果已捕获)。 您可能会发现这样做很有帮助

let stderr = child.stderr.take().unwrap();

为了避免部分移动 child，从而在使用 stderr 时阻止自己在 child 上调用函数。

Implementations

impl Child

pub fn kill(&mut self) -> Result<()>

强制子进程退出。 如果子节点已经退出，则返回 InvalidInput 错误。

到 ErrorKind 的映射不是函数的兼容性契约的一部分。

这等效于在 Unix 平台上发送 SIGKILL。

Examples

基本用法:

use std::process::Command;

let mut command = Command::new("yes");
if let Ok(mut child) = command.spawn() {
    child.kill().expect("command wasn't running");
} else {
    println!("yes command didn't start");
}

pub fn id(&self) -> u32

返回与此子级关联的操作系统分配的进程标识符。

Examples

基本用法:

use std::process::Command;

let mut command = Command::new("ls");
if let Ok(child) = command.spawn() {
    println!("Child's ID is {}", child.id());
} else {
    println!("ls command didn't start");
}

pub fn wait(&mut self) -> Result<ExitStatus>

等待子节点完全退出，并返回退出时的状态。 至少调用一次之后，该函数将继续具有相同的返回值。

子进程的 stdin 句柄 (如果有) 将在等待之前关闭。 这有助于避免死锁: 它确保子进程在父进程等待子进程退出时不会阻止其等待父进程的输入。

Examples

基本用法:

use std::process::Command;

let mut command = Command::new("ls");
if let Ok(mut child) = command.spawn() {
    child.wait().expect("command wasn't running");
    println!("Child has finished its execution!");
} else {
    println!("ls command didn't start");
}

pub fn try_wait(&mut self) -> Result<Option<ExitStatus>>

如果子节点已经退出，则尝试收集其退出状态。

这个函数不会阻塞调用线程，只会检查子进程是否退出。

如果子节点退出了，则在 Unix 上获取进程 ID。 只要子节点已经退出，就可以保证该函数重复返回成功的退出状态。

如果子节点已经退出，则返回 Ok(Some(status))。 如果此时退出状态不可用，则返回 Ok(None)。 如果发生错误，则返回该错误。

请注意，与 wait 不同，此函数不会尝试丢弃 stdin。

Examples

基本用法:

use std::process::Command;

let mut child = Command::new("ls").spawn().unwrap();

match child.try_wait() {
    Ok(Some(status)) => println!("exited with: {}", status),
    Ok(None) => {
        println!("status not ready yet, let's really wait");
        let res = child.wait();
        println!("result: {:?}", res);
    }
    Err(e) => println!("error attempting to wait: {}", e),
}

pub fn wait_with_output(self) -> Result<Output>

同时等待子节点退出并收集 stdout/stderr 句柄上的所有剩余输出，并返回 Output 实例。

子进程的 stdin 句柄 (如果有) 将在等待之前关闭。 这有助于避免死锁: 它确保子进程在父进程等待子进程退出时不会阻止其等待父进程的输入。

默认情况下，stdin、stdout 和 stderr 都是从父级继承的。 为了将输出捕获到此 Result<Output> 中，必须在父级和子级之间创建新管道。 分别使用 stdout(Stdio::piped()) 或 stderr(Stdio::piped())。

Examples

use std::process::{Command, Stdio};

let child = Command::new("/bin/cat")
    .arg("file.txt")
    .stdout(Stdio::piped())
    .spawn()
    .expect("failed to execute child");

let output = child
    .wait_with_output()
    .expect("failed to wait on child");

assert!(output.status.success());

Trait Implementations

impl AsRawHandle for Child

This is supported on Windows only.

fn as_raw_handle(&self) -> RawHandle

提取原始句柄，无需任何所有权。

impl Debug for Child

fn fmt(&self, f: &mut Formatter<'_>) -> Result

使用给定的格式化程序格式化该值。

impl IntoRawHandle for Child

This is supported on Windows only.

fn into_raw_handle(self) -> RawHandle

消费此 object，返回原始基础句柄。