是否有类似Python multiprocessing的Rust工具，可直接在子进程运行函数？

Rust作为静态编译语言，无法直接像Python那样序列化函数并传递给子进程，但可以通过让子进程启动时根据命令行参数触发指定逻辑的方式，实现接近Python multiprocessing.Process的用法，无需编译额外二进制文件。

基础同步实现 #

先实现一个同步版本，核心是让子进程运行当前二进制的特定分支：

use std::process::{Command, ExitStatus};
use std::env;

// 子进程要执行的函数
fn dostuff(name: &str) {
    println!("hello {}", name);
}

// 封装的Process类，模拟Python的API
struct Process {
    child: std::process::Child,
}

impl Process {
    fn spawn(target: &str, args: &[&str]) -> std::io::Result<Self> {
        let exe_path = env::current_exe()?;
        let child = Command::new(exe_path)
            .arg("--subprocess")
            .arg(target)
            .args(args)
            .spawn()?;
        Ok(Self { child })
    }

    fn join(self) -> std::io::Result<ExitStatus> {
        self.child.wait()
    }
}

fn main() -> std::io::Result<()> {
    let args: Vec<String> = env::args().collect();
    // 判定是否为子进程模式
    if args.len() > 1 && args[1] == "--subprocess" {
        let target = &args[2];
        let func_args = &args[3..];
        match target {
            "dostuff" => dostuff(func_args[0]),
            _ => panic!("Unknown target function: {}", target),
        }
        Ok(())
    } else {
        // 主进程逻辑，启动子进程
        let p = Process::spawn("dostuff", &["bob"])?;
        p.join()?;
        Ok(())
    }
}

适配Tokio的异步版本 #

如果要匹配你给出的Tokio异步场景，可以结合tokio::process实现异步的进程管理：

use tokio::process::{Command, Child};
use std::env;
use std::io;

async fn dostuff(name: &str) {
    println!("async hello {}", name);
}

struct AsyncProcess {
    child: Child,
}

impl AsyncProcess {
    async fn spawn(target: &str, args: &[&str]) -> io::Result<Self> {
        let exe_path = env::current_exe()?;
        let child = Command::new(exe_path)
            .arg("--async-subprocess")
            .arg(target)
            .args(args)
            .spawn()?;
        Ok(Self { child })
    }

    async fn join(self) -> io::Result<std::process::ExitStatus> {
        self.child.wait().await
    }
}

#[tokio::main]
async fn main() -> io::Result<()> {
    let args: Vec<String> = env::args().collect();
    if args.len() > 1 && args[1] == "--async-subprocess" {
        let target = &args[2];
        let func_args = &args[3..];
        match target {
            "dostuff" => dostuff(func_args[0]).await,
            _ => panic!("Unknown target async function: {}", target),
        }
        Ok(())
    } else {
        // 替换tokio::spawn为自定义的进程spawn
        let p = AsyncProcess::spawn("dostuff", &["bob"]).await?;
        p.join().await?;
        Ok(())
    }
}

补充说明 #

• 如需传递非字符串类型的复杂参数，可以用serde+bincode序列化后通过命令行参数、标准输入或Redis等IPC方式传递
• 该方案本质是启动当前二进制的副本，通过命令行参数区分主/子进程逻辑，和Python multiprocessing的底层原理一致
• 完全兼容Windows、Linux、macOS等跨平台场景

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