Day 45: std.process模块：进程控制

1. 引言：子进程

除了多线程并发，执行外部命令或创建子进程也是系统编程中的常见需求。Zig通过std.process模块提供了一套强大且跨平台的API来管理子进程。这使得Zig程序可以方便地与其他命令行工具集成，或者将复杂任务分解到多个独立的进程中执行。

本章将介绍如何使用std.process来生成子进程、通过管道（pipe）进行输入输出重定向，以及如何等待子进程结束并获取其状态。

2. Spawn：生成子进程

std.process.spawn函数是创建子进程的核心。它接受一个字符串数组作为参数，其中第一个元素是要执行的命令，后续元素是传递给该命令的参数。

函数签名：

pub fn spawn(argv: []const []const u8) Child

argv: 一个字符串切片，代表命令及其参数。例如 .{ "ls", "-l", "/home" }。

spawn函数返回一个Child结构体，它代表了新创建的子进程。

示例：

const std = @import("std");

pub fn main() !void {
    const argv = &[_][]const u8{ "echo", "Hello from a child process!" };
    var child = std.process.spawn(argv);
    defer child.destroy(); // 确保在作用域结束时清理子进程资源

    const result = try child.wait(); // 等待子进程结束
    std.debug.print("Child process exited with: {}\n", .{result});
}

这个例子中，我们创建了一个子进程来执行echo命令。主进程通过child.wait()等待子进程完成。

3. 管道：重定向输入输出

管道（Pipe）是实现进程间通信（IPC）的常用机制。你可以通过管道将一个进程的输出连接到另一个进程的输入。std.process.Child结构体允许你重定向子进程的标准输入（stdin）、标准输出（stdout）和标准错误（stderr）。

示例：将ls -l的输出通过管道传递给grep .md

const std = @import("std");
const allocator = std.heap.page_allocator;

pub fn main() !void {
    // 创建一个管道
    var pipe = try std.os.pipe();
    defer std.os.close(pipe.read_fd);
    defer std.os.close(pipe.write_fd);

    // 第一个子进程：ls -l，将其stdout重定向到管道的写入端
    const ls_argv = &[_][]const u8{ "ls", "-l" };
    var ls_child = std.process.spawn(ls_argv);
    ls_child.stdout_behavior = .Pipe;
    ls_child.stdout_fd = pipe.write_fd;
    try ls_child.start();
    defer ls_child.destroy();

    // 第二个子进程：grep .md，将其stdin重定向到管道的读取端
    const grep_argv = &[_][]const u8{ "grep", ".md" };
    var grep_child = std.process.spawn(grep_argv);
    grep_child.stdin_behavior = .Pipe;
    grep_child.stdin_fd = pipe.read_fd;
    try grep_child.start();
    defer grep_child.destroy();

    // 关键：在子进程启动后，父进程必须关闭管道的两端
    // 否则子进程可能会一直等待输入而挂起
    std.os.close(pipe.read_fd);
    std.os.close(pipe.write_fd);

    const ls_result = try ls_child.wait();
    const grep_result = try grep_child.wait();

    std.debug.print("ls exited: {}\ngrep exited: {}\n", .{ ls_result, grep_result });
}

4. Wait：等待子进程结束

child.wait()函数用于阻塞父进程，直到子进程执行完毕。它返回一个Child.Exit联合体，包含了子进程的退出信息。

Child.Exit的可能值：

.Code(u8): 子进程正常退出，值为退出码（exit code）。通常0表示成功。
.Signal(u8): 子进程被信号终止，值为信号编号。
.Terminated: 子进程被child.kill()强制终止。
.Stopped(u8): 子进程被信号暂停（用于调试）。

const child = std.process.spawn(.{ "sh", "-c", "exit 42" });
defer child.destroy();

const result = try child.wait();
switch (result) {
    .Code => |code| std.debug.print("Exited with code: {d}\n", .{code}), // 42
    .Signal => |sig| std.debug.print("Terminated by signal: {d}\n", .{sig}),
    else => std.debug.print("Exited with other status\n", .{}),
}

5. 示例：执行Shell命令并捕获输出

一个常见的用例是执行一个shell命令并获取其输出结果。

const std = @import("std");
const allocator = std.heap.page_allocator;

pub fn main() !void {
    const argv = &[_][]const u8{ "zig", "version" };

    // 使用 .Capture 行为来捕获输出
    var child = std.process.spawn(argv);
    child.stdout_behavior = .Capture;
    child.stderr_behavior = .Capture;
    try child.start();
    defer child.destroy();

    const result = try child.wait();

    // 读取stdout
    const output = try allocator.readAll(child.stdout.?.reader());
    defer allocator.free(output);

    std.debug.print("Zig version output:\n{s}\n", .{output});
    std.debug.print("Child process exited with: {}\n", .{result});
}

当stdout_behavior设置为.Capture时，child.stdout会成为一个可选的std.fs.File，你可以从中读取子进程的输出。

6. 实践练习：管道链

任务：创建一个包含三个或更多进程的管道链。例如，模拟 ls -l | grep "src" | wc -l 命令。

创建ls -l进程，将其stdout连接到第一个管道的写入端。
创建grep "src"进程，将其stdin连接到第一个管道的读取端，将其stdout连接到第二个管道的写入端。
创建wc -l进程，将其stdin连接到第二个管道的读取端。
确保正确启动所有进程并关闭父进程中所有不必要的管道文件描述符。
等待所有子进程结束，并打印最终wc -l的输出。

7. 常见问题

子进程收到了什么信号（Signal）？
- 问题：当child.wait()返回.Signal(sig)时，如何知道是哪个信号？
- 解决方案：信号编号是平台相关的。std.os.SIG*常量（例如std.os.SIGTERM, std.os.SIGKILL）定义了常见的信号。你可以将返回的sig与这些常量进行比较。
如何获取子进程的退出码（Exit Code）？
- 问题：如何处理非零的退出码，它通常表示错误？
- 解决方案：检查child.wait()返回的result。如果是.Code(code)，则code就是退出码。一个健壮的程序应该检查code是否为0，并根据非零值执行相应的错误处理逻辑。

8. 总结：与`execve`的对比

std.process模块为Zig提供了高级的、结构化的进程管理接口，它在底层封装了像fork、execve和pipe这样的系统调用。

特性	`std.process` (Zig)	`fork` + `execve` (C/POSIX)
抽象层次	高。封装了`fork-exec`模式和管道设置的复杂性。	低。需要手动调用`fork`，在子进程中调用`execve`，并处理各种边缘情况。
跨平台	是。为不同操作系统（Windows, Linux, macOS）提供统一接口。	否。`fork`是POSIX特有的，Windows有不同的`CreateProcess` API。
安全性	更安全。通过结构化API减少了资源泄漏（如未关闭的FD）和竞争条件的风险。	容易出错。需要手动管理文件描述符、信号处理和进程状态。
易用性	非常高。API直观，易于组合和使用。	复杂。需要对进程生命周期和系统调用有深入理解。

std.process是Zig标准库中一个设计精良的模块，它使得与外部世界（其他程序）的交互变得简单而安全，是编写系统工具和脚本的强大助手。