Process 如何在生锈的Windows上杀死正在运行的子进程？

我有一个在Windows上创建进程的函数

pub fn create_process(url: String) {
    thread::spawn(move || {
        let _child = process::Command::new("cmd.exe")
            .arg("/C")
            .arg("ping")
            .arg(&url)
            .arg("-t")
            .spawn()
            .expect("Couldn't run 'ping'");
    });
}

我有一个函数，我想终止（终止）由“create_process（）”创建的进程：

如何访问在

create\u process

函数中创建的

\u子进程

，以终止其进程？有没有其他方法可以终止这个过程；博士：用这个方法。例如：

use std::process;
use std::thread;
use std::time::Duration;

fn main() {
    let mut child = process::Command::new("ping")
        .arg("8.8.8.8")
        .arg("-t")
        .spawn()
        .expect("Couldn't run 'ping'");

    thread::sleep(Duration::from_secs(5));
    child.kill().expect("!kill");
}

请注意，您不需要单独的线程，因为生成的进程已经与父进程并行

在您的问题中，有一个代码示例使用“cmd/C”运行“ping”。这产生的不是一个而是两个进程：“cmd”进程和“ping”进程。杀死

子进程将杀死“cmd”进程，但可能会使“ping”进程继续运行

使用“cmd/C”也很危险，因为它会导致错误

如何访问在
创建\u进程
函数中创建的
\u子进程
，以终止其进程

\u子线程
，这意味着您可以将其从一个线程发送到另一个线程。跨线程发送数据的细节可能已经包含在一些相应的堆栈溢出问题中

还有其他方法可以终止这个过程吗

您可以使用本机平台API。例如：

use std::process;
use std::thread;
use std::time::Duration;

fn main() {
    let mut child = process::Command::new("ping")
        .arg("8.8.8.8")
        .arg("-t")
        .spawn()
        .expect("Couldn't run 'ping'");

    thread::sleep(Duration::from_secs(5));
    child.kill().expect("!kill");
}

[依赖项]
gstuff=“0.5.2”
winapi={version=“0.3.6”，功能=[“psapi”，“shellapi”]}

#[宏使用]
外部板条箱；
使用std：：过程；
使用std:：ptr:：null_mut；
使用std：：线程；
使用std:：time:：Duration；
使用winapi:：shared:：minwindef:：DWORD；
使用winapi:：shared:：ntdef:：HANDLE；
使用winapi:：um:：processthreadsapi:：{OpenProcess，TerminateProcess}；
使用winapi:：um:：winnt:：{PROCESS\u QUERY\u INFORMATION，PROCESS\u TERMINATE}；
结构进程（句柄）；
impl过程{
fn打开（pid:DWORD）->结果{
// https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320%28v=vs.85%29.aspx
设pc=unsafe{OpenProcess（PROCESS_QUERY_INFORMATION | PROCESS_TERMINATE，0，pid）}；
如果pc==null_mut（）{
返回ERR！（“！OpenProcess”）；
}
Ok（过程（pc））
}
fn杀死（自身）->结果{
不安全{终止进程（self.0，1）}；
好（（））
}
}
进程的impl Drop{
fn下降（&mut自我）{
不安全的{winapi:：um:：handleapi:：CloseHandle（self.0）}；
}
}
fn main（）{
let child=process:：Command:：new（“ping”）
.arg（“8.8.8.8”）
.arg（“-t”）
.spawn（）
.expect（“无法运行“ping”）；
设pid=child.id（）；
让pc=Process:：open（pid为DWORD）。预期（“！open”）；
println！（“进程{}已打开。”，pid）；
线程：：睡眠（持续时间：：从秒（5））；
pc.kill（）.expect（“！kill”）；
println！（“进程{}已终止。”，pid）；
}
非常相关的问题：前导下划线表示未使用变量，但您希望使用
\u child
。请改用
child
。我不知道，谢谢你的评论。
#[macro_use]
extern crate gstuff;

use std::process;
use std::ptr::null_mut;
use std::thread;
use std::time::Duration;
use winapi::shared::minwindef::DWORD;
use winapi::shared::ntdef::HANDLE;
use winapi::um::processthreadsapi::{OpenProcess, TerminateProcess};
use winapi::um::winnt::{PROCESS_QUERY_INFORMATION, PROCESS_TERMINATE};

struct Process(HANDLE);
impl Process {
    fn open(pid: DWORD) -> Result<Process, String> {
        // https://msdn.microsoft.com/en-us/library/windows/desktop/ms684320%28v=vs.85%29.aspx
        let pc = unsafe { OpenProcess(PROCESS_QUERY_INFORMATION | PROCESS_TERMINATE, 0, pid) };
        if pc == null_mut() {
            return ERR!("!OpenProcess");
        }
        Ok(Process(pc))
    }

    fn kill(self) -> Result<(), String> {
        unsafe { TerminateProcess(self.0, 1) };
        Ok(())
    }
}
impl Drop for Process {
    fn drop(&mut self) {
        unsafe { winapi::um::handleapi::CloseHandle(self.0) };
    }
}

fn main() {
    let child = process::Command::new("ping")
        .arg("8.8.8.8")
        .arg("-t")
        .spawn()
        .expect("Couldn't run 'ping'");

    let pid = child.id();
    let pc = Process::open(pid as DWORD).expect("!open");
    println!("Process {} opened.", pid);
    thread::sleep(Duration::from_secs(5));
    pc.kill().expect("!kill");
    println!("Process {} killed.", pid);
}