罗罗编程学习记录 全栈面试题库
本页导航 展开查看

14.6 阶段 5 系统编程与网络

所属:全栈开发面试题库 / 学习路径 / 14 C++ 与系统开发

本页目录

一、阶段定位

本阶段解决"程序怎么跟操作系统打交道、怎么跟网络打交道"。C++ 服务端开发的核心就是系统调用:文件 IO、socket、epoll、信号。不理解这些,写出来的网络库只能跑在回环地址,一上生产就被 TIME_WAIT、C10K、粘包打回。

不掌握本阶段会在后面具体卡在哪:

  • 写了一个 TCP 服务,recv 总是收到不完整的数据——你不知道 TCP 是字节流、没有消息边界,需要自己处理粘包。
  • 多线程 accept 连接,连接数上不去——你不知道阻塞 IO 在高并发下的瓶颈在哪,不会用 epoll。
  • 程序被 kill 后临时文件没删、日志没刷盘——你不知道信号处理怎么写,SIGTERM 来了直接退出。
  • read 返回 -1 后不知道是真错还是只是暂时没数据(EAGAIN),要么 busy loop 要么卡死。

判断自己卡住的标志:(1) 让你说出 read/write/send/recv 的系统调用签名与返回值含义,你只能说"读数据";(2) 给你一段阻塞 socket 代码,你不知道怎么改成非阻塞 + epoll;(3) 你不知道 TCP 三次握手、四次挥手在代码里对应哪些系统调用。出现任一现象,先把本阶段六个模块过一遍再进 阶段 6 性能剖析与工程化。

二、阶段目标与投入

能力目标(可验证的行为) 验证方式
能使用 open/read/write/close 做文件 IO 写一个文件拷贝程序
能写一个 TCP echo 服务(socket/bind/listen/accept/recv/send) 用 telnet 或 nc 测试通过
能说明阻塞 IO、非阻塞 IO、IO 多路复用的区别 给场景选模型
能用 epoll 实现一个简单的事件循环 同时处理 100 个连接不阻塞
能写信号处理函数处理 SIGTERM/SIGINT kill 后程序优雅退出
能说明 TCP 粘包、TIME_WAIT、CLOSE_WAIT 产生原因 用 ss -ant 观察连接状态

建议学时:

  • 全职(每天 4–6 小时):3–4 周,约 60–70 小时。其中文件 IO 8 小时、socket 基础 16 小时、epoll 与 IO 多路复用 16 小时、信号 6 小时、TCP 细节 10 小时、实战 12 小时。
  • 在职(每天 2 小时、周末补 4 小时):6–8 周,约 70 小时。

学时分配:文件 IO 10%、socket 25%、epoll 25%、信号 10%、TCP 细节 15%、实战 15%。

三、先修自检

先修项 合格标准 不合格时怎么办
阶段 4 并发 懂 thread、mutex、condition_variable 回到 阶段 4
操作系统基础 懂进程、文件描述符、用户态/内核态 补操作系统基础
计算机网络 懂 TCP/IP、三次握手、四次挥手 补 01.2 计算机网络
Linux 命令 会用 ss、netstat、lsof、strace 半天熟悉

四、知识地图

模块 知识点 掌握程度 对应题库章节
文件 IO open/read/write/close、pread/pwrite、O_NONBLOCK、O_CLOEXEC 会用 01.1 操作系统
socket socket/bind/listen/accept/connect/recv/send、setsockopt 会用 01.2 计算机网络
IO 模型 阻塞 IO、非阻塞 IO、IO 多路复用(select/poll/epoll)、信号驱动、异步 IO 能讲清原理 01.1 操作系统
epoll epoll_create/epoll_ctl/epoll_wait、水平触发/边缘触发 能讲清原理 09.1 高并发基础
信号 signal/sigaction、SIGTERM/SIGINT/SIGPIPE、异步信号安全 会用 01.1 操作系统
TCP 细节 粘包、拆包、TIME_WAIT、CLOSE_WAIT、SO_REUSEADDR、TCP_NODELAY 能讲清原理 01.2 计算机网络
工具 ss -ant、strace、tcpdump、lsof 会用 01.1 操作系统

五、分模块精讲

5.1 文件 IO 与文件描述符

为什么需要它:一切皆文件——socket、管道、设备在 Linux 里都是文件描述符。理解文件 IO 模型,才能理解 epoll 为什么能监听 socket。

核心机制:

  • 文件描述符(fd):非负整数,进程打开文件的句柄;0 标准输入、1 标准输出、2 标准错误。
  • open(path, flags, mode):打开文件,返回 fd;flags 如 O_RDONLY、O_WRONLY、O_RDWR、O_CREAT、O_APPEND、O_NONBLOCK。
  • read(fd, buf, count):读数据;返回 -1 表示错,0 表示 EOF,>0 表示读到的字节数。
  • write(fd, buf, count):写数据;返回 -1 表示错,>0 表示写入的字节数(可能小于 count,需要循环写)。
  • close(fd):关闭文件描述符。
  • O_CLOEXEC:exec 时自动关闭,防止 fd 泄漏给子进程。

最小可运行示例:

#include <fcntl.h>
#include <iostream>
#include <unistd.h>
#include <cstring>

int main() {
    int fd = open("demo.txt", O_WRONLY | O_CREAT | O_TRUNC, 0644);
    if (fd < 0) { perror("open"); return 1; }
    const char* msg = "hello, syscall\n";
    ssize_t n = write(fd, msg, strlen(msg));
    if (n < 0) { perror("write"); return 1; }
    close(fd);
    return 0;
}

常见坑:

现象 原因 修法
write 返回值小于 count 信号中断或缓冲区满 循环写直到写完
fd 泄漏 open 后异常路径没 close 用 RAII 包装 fd(unique_fd)
子进程继承了不该有的 fd 没设 O_CLOEXEC open 时加 O_CLOEXEC

5.2 socket 基础与 TCP echo

为什么需要它:网络服务的起点就是 socket API。不写一个 echo 服务,后面学 epoll 都是空中楼阁。

核心机制:

  • 服务端流程:socket() → bind() → listen() → accept() → recv()/send() → close()。
  • 客户端流程:socket() → connect() → send()/recv() → close()。
  • setsockopt:设置 SO_REUSEADDR(端口复用)、TCP_NODELAY(禁用 Nagle)、SO_KEEPALIVE(心跳)。
  • recv 返回 0 表示对端关闭连接;返回 -1 表示错(errno 区分 EAGAIN/ECONNRESET 等)。
  • TCP 是字节流:没有消息边界,recv 可能只收到一部分,需要自己处理粘包。

最小可运行示例:

#include <arpa/inet.h>
#include <cstring>
#include <iostream>
#include <netinet/in.h>
#include <sys/socket.h>
#include <unistd.h>

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(8080);

    bind(server_fd, (sockaddr*)&addr, sizeof(addr));
    listen(server_fd, 128);

    std::cout << "echo server on :8080\n";
    while (true) {
        int client_fd = accept(server_fd, nullptr, nullptr);
        char buf[1024];
        ssize_t n = recv(client_fd, buf, sizeof(buf) - 1, 0);
        if (n > 0) {
            buf[n] = '\0';
            std::cout << "received: " << buf;
            send(client_fd, buf, n, 0);          // echo 回去
        }
        close(client_fd);
    }
    return 0;
}

常见坑:

现象 原因 修法
Address already in use 端口 TIME_WAIT setsockopt(SO_REUSEADDR)
recv 收到不完整数据 TCP 字节流无边界 自己处理粘包(长度前缀、分隔符)
send 返回 -1 errno=EPIPE 对端已关闭 处理 SIGPIPE 或检查返回值

5.3 IO 多路复用与 epoll

为什么需要它:阻塞 IO 一个线程只能等一个连接,C10K 问题来了——10000 个连接要 10000 个线程,不现实。epoll 用一个线程等所有连接。

核心机制:

  • 五种 IO 模型:阻塞 IO、非阻塞 IO、IO 多路复用(select/poll/epoll)、信号驱动 IO、异步 IO(AIO)。
  • select/poll:用数组传 fd,每次遍历所有 fd;O(n) 复杂度,10000 个 fd 性能差。
  • epoll:epoll_create 创建实例;epoll_ctl 注册/修改/删除 fd;epoll_wait 等待事件。
  • 水平触发(LT):默认;只要 fd 可读就一直通知,直到读完。
  • 边缘触发(ET):只在状态变化时通知一次;必须非阻塞 + 循环读到 EAGAIN。
  • epoll 高性能原因:内核维护红黑树管理 fd,就绪链表返回就绪事件,O(1) 获取就绪 fd。

最小可运行示例:

#include <epoll.h>
#include <iostream>
#include <unistd.h>
#include <netinet/in.h>
#include <sys/socket.h>

int main() {
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;
    addr.sin_port = htons(8080);
    bind(server_fd, (sockaddr*)&addr, sizeof(addr));
    listen(server_fd, 128);

    int epfd = epoll_create1(0);
    epoll_event ev{};
    ev.events = EPOLLIN;
    ev.data.fd = server_fd;
    epoll_ctl(epfd, EPOLL_CTL_ADD, server_fd, &ev);

    epoll_event events[128];
    while (true) {
        int n = epoll_wait(epfd, events, 128, -1);
        for (int i = 0; i < n; ++i) {
            if (events[i].data.fd == server_fd) {
                int client_fd = accept(server_fd, nullptr, nullptr);
                epoll_event cev{};
                cev.events = EPOLLIN;
                cev.data.fd = client_fd;
                epoll_ctl(epfd, EPOLL_CTL_ADD, client_fd, &cev);
            } else {
                char buf[1024];
                ssize_t r = recv(events[i].data.fd, buf, sizeof(buf), 0);
                if (r <= 0) {
                    close(events[i].data.fd);
                    epoll_ctl(epfd, EPOLL_CTL_DEL, events[i].data.fd, nullptr);
                } else {
                    send(events[i].data.fd, buf, r, 0);
                }
            }
        }
    }
    return 0;
}

常见坑:

现象 原因 修法
ET 模式漏数据 没循环读到 EAGAIN ET 必须非阻塞 + 循环读
epoll_wait 高 CPU fd 一直就绪但没读完 LT 模式读完,或检查是否真读完
惊群 多进程/线程同时 accept 用 EPOLLEXCLUSIVE 或 SO_REUSEPORT

5.4 信号处理

为什么需要它:程序被 kill、Ctrl+C、SIGPIPE 时要优雅退出——刷盘、关连接、删临时文件。

核心机制:

  • 常用信号:SIGINT(Ctrl+C,2)、SIGTERM(kill 默认,15)、SIGKILL(不可捕获,9)、SIGPIPE(写已关闭 socket)、SIGCHLD(子进程退出)。
  • sigaction(推荐,比 signal 可移植):注册信号处理函数。
  • 信号处理函数是异步的:不能调用非异步信号安全函数(malloc、printf、std::cout),只能用 write、_exit、设置全局 atomic flag。
  • 常见模式:信号处理函数只设 atomic<bool> g_stop{false},主循环检查这个 flag 优雅退出。

最小可运行示例:

#include <atomic>
#include <iostream>
#include <signal.h>
#include <unistd.h>

std::atomic<bool> g_stop{false};

void handle_signal(int sig) {
    (void)sig;
    g_stop = true;
}

int main() {
    struct sigaction sa{};
    sa.sa_handler = handle_signal;
    sigaction(SIGINT, &sa, nullptr);
    sigaction(SIGTERM, &sa, nullptr);
    signal(SIGPIPE, SIG_IGN);              // 忽略 SIGPIPE,防止写已关闭连接崩溃

    while (!g_stop) {
        sleep(1);
        std::cout << "working...\n";
    }
    std::cout << "graceful shutdown\n";
    return 0;
}

常见坑:

现象 原因 修法
信号处理函数里 printf 崩溃 printf 非异步信号安全 只设 atomic flag,主循环处理
SIGPIPE 导致程序退出 写已关闭 socket signal(SIGPIPE, SIG_IGN)
SIGKILL 捕获不到 9 号信号不可捕获 用 SIGTERM 做优雅退出

5.5 TCP 细节与排障

为什么需要它:网络服务上线后 80% 的问题不是代码 bug,而是 TCP 状态、粘包、缓冲区、连接数限制。

核心机制:

  • 粘包:TCP 字节流,recv 可能一次收到多条消息或只收到半条。解法:长度前缀(4 字节长度 + 消息体)、分隔符(\n)、固定长度。
  • TIME_WAIT:主动关闭方经过 2MSL 才关闭;高并发短连接会堆积 TIME_WAIT。解法:SO_REUSEADDR、用长连接、调内核参数。
  • CLOSE_WAIT:被动关闭方收到 FIN 后没 close 自己的 socket;说明代码 bug。
  • ss -ant:查看连接状态;ESTABLISHED 正常,TIME_WAIT 多说明短连接多,CLOSE_WAIT 多说明泄漏。
  • tcpdump:抓包看实际收发内容。

最小可运行示例:

# 查看连接状态统计
ss -ant | awk '{print $1}' | sort | uniq -c

# 抓包看 8080 端口
tcpdump -i any port 8080 -nn

# 跟踪系统调用
strace -f -e trace=network ./app

常见坑:

现象 原因 修法
TIME_WAIT 堆积 短连接多 用长连接、调 tcp_tw_reuse
CLOSE_WAIT 堆积 代码漏 close 检查是否所有连接都 close
recv 粘包 字节流无边界 长度前缀协议
accept 慢 fd 限制 ulimit -n 调高,或 sysctl

5.6 非阻塞 IO 与事件循环

为什么需要它:epoll 配合非阻塞 fd,才能真正做到一个线程处理成千上万连接。阻塞 fd 在 epoll 里会卡住。

核心机制:

  • 设 fd 为非阻塞:fcntl(fd, F_SETFL, O_NONBLOCK)。
  • 非阻塞 recv:没数据时返回 -1,errno=EAGAIN/EWOULDBLOCK;有数据时返回读到的字节数。
  • 事件循环:epoll_wait 拿到就绪事件 → 读/写 → 数据没读完继续等下一次 EPOLLIN,写缓冲区满了等 EPOLLOUT。
  • 这是 muduo、boost.asio、libevent 的核心模型。

六、分层练习

6.1 复现型

练习 要求 验收标准 预计耗时
文件拷贝 用 open/read/write 写文件拷贝 拷贝后文件一致 1 小时
TCP echo 服务 用 socket API 写 echo nc/telnet 测试通过 2 小时
epoll 事件循环 用 epoll 改写 echo,同时处理 100 连接 100 个连接同时 echo 3 小时
信号优雅退出 SIGTERM 后程序刷盘退出 kill 后日志完整 1 小时
ss 看连接状态 起服务后用 ss 统计 能区分 ESTABLISHED/TIME_WAIT 1 小时

6.2 改造型

练习 要求 验收标准 预计耗时
修 TIME_WAIT 短连接导致 TIME_WAIT 堆积,加 SO_REUSEADDR TIME_WAIT 数量下降 1 小时
修粘包 给 echo 加长度前缀协议 客户端发长消息不拆包 2 小时
修 CLOSE_WAIT 故意漏 close,用 ss 发现并修复 CLOSE_WAIT 归零 1 小时
阻塞改非阻塞 把阻塞 echo 改成非阻塞 + epoll 单线程处理 100 连接 3 小时

6.3 设计型

练习 要求 验收标准 预计耗时
设计一个简单 RPC 框架 长度前缀 + 消息头 + epoll 客户端发请求服务端响应 6 小时
整理 TCP 排障手册 ss/tcpdump/strace 常用命令 10 条以上命令可照抄 2 小时
对比 select/poll/epoll 画图说明三种模型复杂度 能讲清 epoll 高性能原因 2 小时

七、排障表

现象 可能原因 排查步骤 解决办法
Address already in use 端口 TIME_WAIT ss -ant | grep 8080 setsockopt(SO_REUSEADDR)
recv 收到不完整数据 TCP 字节流无边界 看收到的字节数 长度前缀协议
send 后 SIGPIPE 退出 对端已关闭 看 errno signal(SIGPIPE, SIG_IGN)
epoll_wait 高 CPU fd 一直就绪没读完 看 recv 是否返回 EAGAIN 循环读到 EAGAIN
连接数上不去 fd 限制 ulimit -n 调高限制
CLOSE_WAIT 堆积 代码漏 close ss -ant | grep CLOSE_WAIT 检查所有 close 路径
TIME_WAIT 堆积 短连接多 ss -ant | grep TIME_WAIT 长连接、调内核参数
accept 惊群 多进程同时 accept 看连接分布 SO_REUSEPORT 或 EPOLLEXCLUSIVE

八、出口条件

全部勾选后进入 阶段 6 性能剖析与工程化。

  • [ ] 能用 open/read/write 做文件 IO,正确处理返回值
  • [ ] 能用 socket API 写一个 TCP echo 服务
  • [ ] 能说明阻塞、非阻塞、IO 多路复用的区别
  • [ ] 能用 epoll 实现一个简单事件循环处理多连接
  • [ ] 能写信号处理函数实现优雅退出
  • [ ] 能用 ss/tcpdump/strace 排查网络问题
  • [ ] 能说明粘包、TIME_WAIT、CLOSE_WAIT 的产生原因与解法

自测题:

  1. TCP 为什么会粘包?怎么处理?
    • 要点:TCP 是字节流无消息边界;用长度前缀、分隔符或固定长度分包。
  2. epoll 为什么比 select/poll 快?
    • 要点:select/poll 每次传所有 fd 并 O(n) 遍历;epoll 内核维护红黑树,就绪事件通过链表返回,O(1) 获取就绪 fd。
  3. LT 与 ET 的区别?ET 模式为什么必须非阻塞?
    • 要点:LT 只要可读就通知直到读完;ET 只在状态变化时通知一次;ET 必须非阻塞循环读到 EAGAIN,否则会饿死。
  4. TIME_WAIT 是怎么产生的?怎么减少?
    • 要点:主动关闭方经过 2MSL;短连接多会堆积;用长连接、SO_REUSEADDR、调 tcp_tw_reuse。
  5. 信号处理函数里为什么不能调用 printf?
    • 要点:printf 非异步信号安全,可能持有锁时被信号打断导致死锁;只能设 atomic flag。
  6. CLOSE_WAIT 堆积说明什么问题?
    • 要点:被动关闭方收到 FIN 但没 close 自己的 socket,代码泄漏。