线上最常见的两种「资源型故障」,症状都很像:服务本身逻辑没改,重启就好,过一阵又犯。第一种是打开文件失败,日志里是 Too many open files;第二种是子进程退出了却一直挂在进程表里,ps 里状态写着 Z,名字后面带 <defunct>。前者是文件描述符没还,后者是子进程没人收尸。
这两个问题都不属于 C++ 语言层面,写多少模板、用多新的标准都防不住。它们属于操作系统给程序提供的那套接口——POSIX 系统调用。这篇要讲清:系统调用到底是什么、文件描述符这套编号怎么用、出错时为什么统一返回 -1 并设置 errno、fork 和 exec 怎么配合、僵尸进程是怎么产生的、管道和信号的基本用法、strace 能帮你看什么,以及为什么「write 成功了但数据没落盘」。
fork、exec、waitpid、pipe、signal、strace 的示例,都需要 Linux/POSIX 环境。本机是 Windows + MinGW(g++ 16.2.0),有 unistd.h、open、getpid,但没有 fork 和 pipe,这些示例在本机未实测,编译会直接报错。文中只描述「预期行为」,不伪造终端输出。两个现象,都指向同一层
先说 Too many open files。这个报错不是文件系统说的,是内核在 open() 时拒绝分配新的文件描述符:每个进程的 fd 数量有上限(常见默认 1024,可调),用完就报 EMFILE。典型成因是代码里 open 之后某条异常路径提前 return,close 没执行到;或者每条连接都打开一个文件却从不关闭。它不会立刻爆,往往跑几天、几周才出现。
再说僵尸进程。子进程退出时不会立刻从进程表消失,它要等父进程调用 wait 系列函数把退出状态取走,才真正被清理。父进程如果从来不 wait,子进程就停在「已退出但未回收」的状态,这就是僵尸。ps 里能看到它,但它不占 CPU、不占内存,只占一个进程表项,所以容易被忽略——直到表项被耗尽,新的 fork 失败。
两个故障的共同点是:代码里看不到它们,它们记在操作系统的账上。要会查这笔账,得先知道账本长什么样。
系统调用是什么
普通函数调用只是在同一个进程里跳转,系统调用要跨过一条边界:从用户态进入内核态。用户态的程序不能直接碰磁盘、网卡、页表这些资源,只能通过内核事先开好的入口请求它代办,办完再切回来。这条入口就是系统调用,切换本身有开销,通常在三五百纳秒到微秒之间,具体随平台和 CPU 安全 mitigations 变化。
我们平时写的 open、read、fork 并不是内核函数的直接地址,而是 C 库提供的同名包装:把参数按调用约定摆好,触发切换,再把内核的返回值翻译回来。C++ 的 std::fstream、std::filesystem 更靠上一层,最终也要落到这些调用上。
这带来两个实际后果。第一,标准库函数不等于系统调用:printf 多数时候只是往缓冲区里写,真正的 write 可能一次都没发生。第二,系统调用是平台相关的:POSIX 定义了 Unix 系这一套,Windows 是另一套 API(CreateFile、ReadFile),MinGW 只提供了其中一部分兼容层,所以 fork 这种 Unix 特有的东西在 Windows 上不存在。
文件描述符:一个整数代表一切
内核不把「打开的文件」直接交给你,而是给一个非负整数,叫文件描述符(file descriptor,fd)。它本质上是当前进程 fd 表的下标。0、1、2 固定分给标准输入、标准输出、标准错误,所以新开的文件通常从 3 开始。这个模型有三层,理解它才能理解 dup2 和 fork 的行为:
由此推出几条容易记错的规则:close(fd) 只是把当前进程的引用减一,另一个进程的同名 fd 仍然可用;dup(fd) 复制一个指向同一打开文件描述的新下标,两者共享偏移;dup2(old, new) 把 new 强行指向 old 的描述,常用于把标准输出重定向到文件。文件名可以删掉而文件仍然可读写,因为 inode 还被打开的文件描述引用着。
下面这个例子把三件事串起来:打开日志文件、fork 出子进程、在子进程里把标准输出重定向到该文件,然后 exec 执行外部命令,父进程负责回收。编译命令(Linux 环境):
#include <cerrno>
#include <cstdio>
#include <cstdlib>
#include <fcntl.h>
#include <sys/wait.h>
#include <unistd.h>
int main() {
int fd = ::open("child.log", O_WRONLY | O_CREAT | O_TRUNC, 0644);
if (fd == -1) {
std::perror("open");
return 1;
}
pid_t pid = ::fork();
if (pid == -1) {
std::perror("fork");
::close(fd);
return 1;
}
if (pid == 0) {
// 子进程:让 stdout 指向这个文件,然后换成 echo 的进程映像
if (::dup2(fd, STDOUT_FILENO) == -1) {
std::perror("dup2");
::_exit(1);
}
::close(fd);
::execlp("echo", "echo", "hello from child", (char*)nullptr);
std::perror("execlp");
::_exit(127); // exec 失败才会走到这里
}
::close(fd); // 父进程不再需要这个 fd
int status = 0;
while (::waitpid(pid, &status, 0) == -1 && errno == EINTR) {
// 被信号打断就重试
}
if (WIFEXITED(status)) {
std::printf("child exit=%d\n", WEXITSTATUS(status));
}
return 0;
}
g++ -std=c++20 -Wall -Wextra posix_demo.cpp -o posix_demo
预期行为(本文未实测):child.log 里出现 hello from child,终端打印 child exit=0。走一遍逻辑:fork 之后有两个进程同时从 if (pid == 0) 往下走,子进程里 pid 是 0,父进程里是子进程的 pid;子进程 dup2 后 fd 1 指向日志文件,所以 echo 的输出进了文件而不是终端;execlp 成功就再也不返回,进程映像被整个替换;父进程 waitpid 阻塞到子进程结束,拿到退出码。
这个例子在本机 Windows + MinGW 上编译会直接失败,报 'fork' was not declared in this scope——这是本机实测的编译器提示,不是代码写错。它说明 fork 不是 C++ 标准的一部分,只在 POSIX 平台可用。
错误处理:-1、errno 和 EINTR
POSIX 系统调用有一套统一约定:失败返回 -1(或空指针),并把具体原因写进 errno。errno 是线程局部变量,所以多个线程同时出错不会互相覆盖。判断顺序必须是「先看返回值,再读 errno」——成功的调用不会清空 errno,里面可能残留上一次的旧值。
#include <cerrno>
#include <cstdio>
#include <cstring>
int fd = ::open("data.bin", O_RDONLY);
if (fd == -1) {
std::fprintf(stderr, "open failed: %s (errno=%d)\n",
std::strerror(errno), errno);
return 1;
}
第二个必须养成的习惯是处理 EINTR。进程收到信号时,正在阻塞的系统调用可能被打断,提前返回 -1 并设 errno = EINTR。这不是真的失败,正确做法是重试。不处理的话,程序会在「偶尔收到一个信号」的路径上莫名其妙地报错,而且很难复现。
ssize_t n;
do {
n = ::write(fd, buf, len);
} while (n == -1 && errno == EINTR);
还有一点常被忽略:write 返回成功不代表写了 len 个字节。它可能只写了一半(部分写),尤其是非阻塞 fd 或大 buffer。所以真实代码要循环累加已写长度,直到写完或遇到真错误。read 同理,返回 0 表示对端关闭(EOF),不是「读到 0 个字节的数据」。
fork、exec、waitpid 与僵尸
fork 复制当前进程,返回两次:子进程里返回 0,父进程里返回子进程的 pid,失败返回 -1。现代内核用写时复制(COW),不会真的把整块内存拷一遍,但页表还是要复制,进程越大 fork 越慢。
exec 系列把当前进程的地址空间、堆栈、代码全部换成另一个程序,从它的 main 开始跑。成功时它不返回;返回就说明失败了(比如找不到可执行文件),这时应该用 _exit 而不是 exit。
父进程用 waitpid(pid, &status, 0) 等子进程结束并回收。必须用 WIFEXITED(status) 判断是否正常退出,再用 WEXITSTATUS(status) 取退出码;如果是被信号杀死的,就要看 WIFSIGNALED 和 WTERMSIG。直接把 status 当退出码用,会得到奇怪的大数字。
不 wait 的后果就是僵尸。很多人以为「子进程跑完就自动没了」,其实它只是在等父进程取走最后的状态。父进程如果先于子进程退出,子进程会被 init(或容器里的 1 号进程)收养,那时才会有人回收;如果父进程一直活着却从不 wait,僵尸就会一直积累。
printf、malloc、std::cout 都不在其中。常见做法是在 handler 里只置一个 volatile sig_atomic_t 标志,或让 waitpid 带 WNOHANG 在主循环里轮询。管道与信号
pipe(fds) 一次创建两个 fd:fds[0] 读端,fds[1] 写端,数据先进先出,是半双工的。它最常用的场景是父进程读子进程的输出:fork 前建管道,子进程 dup2 把 stdout 接到写端,父进程关掉自己的写端再 read 读端。关闭写端之后,读端的 read 才会在数据读完后返回 0(EOF);如果父进程忘了关自己的写端,读端会一直等,看起来就像卡死。
反过来,如果读端已经关闭而写端还在写,内核会给写进程发 SIGPIPE,默认行为是直接终止进程。很多服务会忽略它,改为检查 write 返回的 EPIPE,这样能优雅地处理对端断开。
信号是内核给进程的异步通知。SIGINT 对应 Ctrl+C,SIGTERM 是常规终止请求,SIGCHLD 在子进程状态变化时发出,SIGPIPE 如上。注册处理函数用 sigaction 而不是老的 signal,语义更明确。信号处理函数能被随时打断,所以里面只能做极小的事:置标志、写一个自管道、_exit。
strace:看程序到底跟内核说了什么
怀疑程序卡住、找不到文件、fd 泄漏时,最省时间的工具是 strace。它把进程发出的每个系统调用、参数和返回值都打出来。常用几种:
strace -f ./app:跟着 fork 出来的子进程一起看。strace -e trace=openat,read,write,close ./app:只看关心的几类,输出不会被淹没。strace -p <pid>:attach 到已经在跑的进程,适合查「卡在哪」。strace -c ./app:统计各类调用的次数和耗时,先看量级再决定细查哪一类。
看输出时重点看两样:返回值和 errno。比如一串 openat(...) = -1 EMFILE 就是 fd 用光了;read(...) = -1 EINTR 说明被信号打断;某个 read 之后长时间没有下一条,基本就是阻塞在那里。注意 attach 会拖慢目标进程,生产环境要谨慎,能抓短时间就别长时间挂着。
缓冲、fsync 与 fork 的坑
write 返回成功只表示数据进了内核的页缓存,不代表已经到了磁盘。机器掉电时,这部分数据可能丢。要确保落盘得调用 fsync(fd) 或 fdatasync(fd),它们会等真正写进持久介质;代价是慢,机械盘上一次 fsync 可能是毫秒级。日志、数据库的 WAL 都在这个取舍上做文章:批量提交、组提交,而不是每条记录都 fsync。
if (::write(fd, buf, len) == -1) { /* 处理错误 */ }
if (::fsync(fd) == -1) { /* fsync 也会失败,也要查 errno */ }
另一组坑来自 fork 和 C++ 混用。fork 只复制调用它的那个线程,其他线程在子进程里直接消失;如果它们当时正持有 malloc 或 iostream 内部的锁,子进程再去分配内存、写 std::cout,就可能永久卡住。标准只说 fork 之后到 exec 之前,子进程只能调用 async-signal-safe 的函数。所以「多线程程序 fork 完继续跑 C++ 逻辑」是非常危险的做法。
还有一个现象是 fork 后输出重复:父进程的 stdio 缓冲区里如果还有没刷出的内容,fork 会把缓冲区一起复制,父子进程各自 exit 时各刷一次,同一行就打印了两遍。子进程用 _exit 绕过 exit 的清理,或者 fork 前 fflush,都能避免。
现象、原因、先查什么
系统调用相关的故障,查的顺序通常是「先看资源账本,再看返回值,最后看调用序列」。
| 你看到的现象 | 真实原因 | 第一步查什么 |
|---|---|---|
open 报 Too many open files(EMFILE) | fd 泄漏:异常路径跳过 close,或连接只开不关 | ls /proc/<pid>/fd | wc -l 或 lsof -p <pid>,看数量和类型是否持续增长 |
ps 里一排 Z / <defunct> | 子进程退出但父进程没 waitpid | 看僵尸的 PPID 是谁,查父进程的 wait 逻辑和 SIGCHLD 处理 |
| fork 后同一行日志打印两遍 | 父子进程共享 stdio 缓冲区,各自 exit 刷一次 | 子进程改用 _exit,或 fork 前 fflush |
read/write 偶尔返回 -1,errno 是 EINTR | 阻塞调用被信号打断 | 循环重试,只在 errno 不是 EINTR 时才当失败 |
| 写日志「成功」但断电后文件是空的 | 只写进页缓存,没有 fsync | 检查是否调用 fsync,以及它的返回值有没有被忽略 |
| 管道读端一直阻塞,或写端收到 EPIPE | 写端没关(读端等不到 EOF),或读端提前退出 | 确认两端该关的 fd 都关了;检查 SIGPIPE 处理和 EPIPE 分支 |
| 子进程刚 fork 完就卡死,栈在 malloc 或 iostream | fork 时别的线程持有堆或流内部的锁 | fork 后只调 async-signal-safe 函数,尽快 exec;或改用 posix_spawn |
第一行最值得注意:fd 泄漏往往不是「没写 close」,而是某条很少走的分支漏了。把 fd 包成 RAII 对象,让析构负责 close,比在每个 return 前手动补一行可靠得多。
边界与代价
直接使用系统调用换来的是控制力,代价也得认。
- 不可移植。
fork、pipe、dup2在 Windows 上不存在或语义不同;跨平台代码要么抽象一层,要么用标准库能覆盖的部分。 - 错误处理冗长。几乎每个调用都要判断返回值、区分 EINTR、处理部分读写。这是 C 风格接口的固有成本,可以用 RAII 和小包装函数收敛。
- 绕过缓冲可能更慢。一次
read一个字节,调用开销远大于数据本身;批量读写、合理设置缓冲区,比「直接用最底层的调用」更快。 - fork 在现代程序里越来越重。大内存、多线程的进程 fork 要复制页表,COW 也会带来后续的缺页开销;能
posix_spawn就别手写 fork+exec。 - 权限与隔离。系统调用直接受用户权限、容器 namespace、seccomp 限制,报
EPERM时先查运行身份和沙箱策略,别先怀疑代码。
但这一层不能不学。所有「文件打不开、进程退不掉、数据没落盘、程序卡在 read」的问题,最终都要落到这里;标准库只是把它包得好看了一点。
当天能验证的练习
下面几条都需要 Linux 环境(本机 Windows + MinGW 缺 fork/pipe,无法完成):
- 在程序里循环
open同一个文件且不close,打印每次的 fd,看它从 3 开始递增,直到报EMFILE;先用ulimit -n看当前上限。 - 写一个 fork 后不 wait 的程序,让它连续创建几个立即退出的子进程,用
ps -o pid,ppid,stat,cmd观察Z状态;再加上waitpid看僵尸是否消失。 - 用
pipe让子进程写、父进程读;先试「父进程不关写端」,观察read为什么不返回;再关闭写端,确认读到 EOF(返回 0)。 strace -c ./你的程序看一次运行里各类系统调用的次数,再用strace -e trace=openat ./程序找它到底打开了哪些文件。- 让程序写一个文件但不
fsync,正常退出后用cat看内容;再在write后加fsync,对比耗时,理解「落盘」的成本。
小结与往后走
三句话收尾:fd 是进程资源账本上的编号,open 和 close 必须成对,异常路径也不例外;系统调用失败统一返回 -1 加 errno,EINTR 要重试;子进程退出后必须有人 wait,否则就是僵尸。
到这里,「C++ 系统编程」这条线的基础部分就告一段落了:从源码怎么变成可执行文件,到类型和对象怎么占内存,再到错误怎么传、线程怎么并行、程序怎么跟内核打交道。接下来的五篇会把几个方向逐个展开:文件系统、网络编程、异步与协程、共享内存与 IPC、并发进阶。它们都建立在本篇这套 fd 和进程模型上,先把账本看明白,后面的工具才不会用得像魔法。
fork、pipe、waitpid、信号与 strace 均不可用,相关代码未编译、未运行;文中行为描述为预期行为,不是实测输出。