0. 前言

上一天我们手写了多进程TCP并发服务器，成功实现多客户端同时通信。但我们留下了一个巨大的性能瓶颈：多进程模型无法支撑高并发。

每来一个客户端就要创建一个进程，Linux系统进程资源极其昂贵，单个服务器最多支撑几百个并发，一旦连接量上千上万，系统会直接卡死、资源耗尽、无法响应。

想要实现百万并发、高吞吐、低延迟的工业级服务器（Nginx/Redis底层核心），必须彻底吃透Linux 四大IO模型 + Epoll多路复用机制。

IO模型是计算机网络、操作系统内核、后端底层开发的终极分水岭。绝大多数面试者只会背：select/poll/epoll区别，却完全不知道：

为什么阻塞IO并发低？非阻塞IO有什么问题？多路复用的本质是什么？epoll水平触发和边缘触发区别？为什么epoll是Linux并发天花板？

今天这篇文章，我们从操作系统IO原理逐层拆解，对比四大IO模型，从零手写epoll高并发反应堆服务器，彻底打通 Linux内核 + 网络高并发底层，所有代码可直接编译运行，纯C++底层、无框架、无Java，简历硬核项目直接成型！

1. 操作系统IO底层本质（必懂核心）

所有网络IO的底层，全部遵循操作系统统一机制：用户态、内核态数据拷贝 + 内核缓冲区就绪检测。

一次完整的网络读IO分为两步：

1. 等待数据就绪：内核缓冲区是否收到客户端数据（耗时最长）

2. 数据拷贝：从内核缓冲区拷贝数据到用户态内存

所有IO模型的区别，只区别在第一步：如何等待数据就绪。

理解这一点，你就彻底看懂所有IO模型！

2. 四大IO模型超全对比（面试满分）

2.1 阻塞IO（Blocking IO）

默认Socket模型，也是我们上一节多进程服务器使用的模型。

原理：调用 read/accept 时，如果内核缓冲区无数据，线程/进程彻底阻塞、挂起，不占用CPU，一直等到数据就绪才返回。

优点：代码简单、稳定、无空转CPU消耗；

致命缺点：单线程只能处理一个连接，想要并发必须开多进程/多线程，资源开销极大，并发上限极低。

2.2 非阻塞IO（Non-Blocking IO）

原理：Socket设置为非阻塞模式，调用read时，无数据不阻塞、直接返回错误，用户程序不断轮询询问内核是否就绪。

优点：单线程可以管理多个Socket；

致命缺点：极度浪费CPU，绝大多数时间都是无效轮询，CPU跑满100%，生产环境绝对禁用。

2.3 IO多路复用（IO Multiplexing）

工业级高并发核心模型，Nginx、Redis、Tomcat底层全部基于此实现。

原理：单线程将所有Socket文件描述符交给内核监控，线程阻塞等待，只要任意一个Socket数据就绪，内核通知用户线程处理。

核心优势：单线程管理成千上万个连接，无进程线程开销、无CPU空转，并发能力碾压多进程模型。

Linux提供三种多路复用函数：select、poll、epoll，性能逐级提升。

2.4 信号驱动IO / 异步IO（拓展了解）

信号驱动IO：内核就绪后发送信号通知程序；AOF异步IO由内核全程完成拷贝，用户线程无需等待。日常网络开发核心使用epoll多路复用。

3. select/poll/epoll 深度对比（面试绝杀考点）

3.1 select 缺点

1. 最大文件描述符有限制（默认1024），并发上限低；

2. 每次调用需要重新传入fd集合，用户态频繁拷贝；

3. 内核返回就绪集合后，用户态需要全量遍历所有fd，效率随连接数升高急剧下降；

4. 不支持边缘触发，只能水平触发。

3.2 poll 缺点

解决了select的1024上限问题，但依然存在：全量遍历、频繁拷贝、无就绪索引，海量连接下性能依然拉胯。

3.3 epoll 优势（Linux终极IO模型）

epoll是Linux内核专为高并发设计的多路复用模型，彻底解决select/poll所有缺陷：

1. 无最大fd限制：仅受系统内存限制，支持十万、百万级并发；

2.事件就绪回调机制：内核维护就绪链表，仅返回就绪fd，无需全量遍历；

3. 内存映射mmap：减少用户态与内核态数据拷贝开销；

4. 支持LT水平触发 / ET边缘触发，高性能场景首选ET边缘触发。

4. Epoll核心机制详解（LT/ET触发区别）

4.1 水平触发 LT（Level Trigger）

默认模式。只要缓冲区有数据未读完，epoll每次监听都会持续通知就绪，直到数据全部读取完毕。

优点：代码容错高、不容易丢数据；

缺点：频繁触发事件，性能不如ET。

4.2 边缘触发 ET（Edge Trigger）

高性能模式，Nginx默认使用。仅在数据第一次到达的瞬间触发一次，后续残留数据不会再次触发。

要求极高：必须一次性读完缓冲区所有数据，否则数据残留永远无法触发事件，造成数据丢失。

优点：触发次数极少，CPU开销最低，极致高性能。

4.3 面试满分总结

LT：有数据就触发，安全低效；

ET：数据新来只触发一次，高效但要求一次性读完缓冲区。

5. 手写Epoll高并发服务器（单线程百万并发）

本节手写工业级epoll反应堆模型，实现：单线程监听多连接、ET边缘触发、非阻塞IO、一次性读满缓冲区、杜绝数据残留、支持海量并发，完全对标Nginx底层IO模型。

5.1 核心前置配置

epoll三大核心API：

1. epoll_create()：创建epoll内核实例

2. epoll_ctl()：增删改需要监听的fd事件

3. epoll_wait()：阻塞等待就绪事件

5.2 完整可编译源码

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

using namespace std;

#define PORT 8888
#define MAX_EVENTS 1024
#define BUF_SIZE 1024

// 设置文件描述符为非阻塞
int set_nonblock(int fd) {
    int flag = fcntl(fd, F_GETFL, 0);
    fcntl(fd, F_SETFL, flag | O_NONBLOCK);
    return 0;
}

int main() {
    // 1. 创建服务端socket
    int server_fd = socket(AF_INET, SOCK_STREAM, 0);
    set_nonblock(server_fd);

    // 端口复用
    int opt = 1;
    setsockopt(server_fd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    // 绑定端口
    struct sockaddr_in addr;
    memset(&addr, 0, sizeof(addr));
    addr.sin_family = AF_INET;
    addr.sin_port = htons(PORT);
    addr.sin_addr.s_addr = htonl(INADDR_ANY);
    bind(server_fd, (struct sockaddr*)&addr, sizeof(addr));
    listen(server_fd, 5);

    // 2. 创建epoll实例
    int epoll_fd = epoll_create1(0);
    struct epoll_event ev, events[MAX_EVENTS];

    // 注册监听事件：边缘触发、读事件
    ev.events = EPOLLIN | EPOLLET;
    ev.data.fd = server_fd;
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_fd, &ev);

    cout << "Epoll高并发服务器启动成功！端口：" << PORT << endl;

    while (true) {
        // 3. 阻塞等待事件就绪
        int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);

        for (int i = 0; i < nfds; i++) {
            int fd = events[i].data.fd;

            // 事件1：监听到新客户端连接
            if (fd == server_fd) {
                struct sockaddr_in client_addr;
                socklen_t len = sizeof(client_addr);
                int conn_fd = accept(server_fd, (struct sockaddr*)&client_addr, &len);
                if (conn_fd < 0) continue;

                set_nonblock(conn_fd);
                // 将新连接加入epoll监听
                ev.events = EPOLLIN | EPOLLET;
                ev.data.fd = conn_fd;
                epoll_ctl(epoll_fd, EPOLL_CTL_ADD, conn_fd, &ev);

                cout << "客户端接入：" << inet_ntoa(client_addr.sin_addr) << endl;
            }
            // 事件2：客户端数据可读
            else {
                char buf[BUF_SIZE] = {0};
                int total = 0;
                int ret;

                // ET边缘触发：循环一次性读完所有数据
                while ((ret = read(fd, buf + total, BUF_SIZE - 1)) > 0) {
                    total += ret;
                }

                // 客户端断开连接
                if (total == 0) {
                    epoll_ctl(epoll_fd, EPOLL_CTL_DEL, fd, NULL);
                    close(fd);
                    cout << "客户端断开连接" << endl;
                    continue;
                }

                cout << "收到数据：" << buf << endl;
                // 数据回显
                write(fd, buf, total);
            }
        }
    }

    close(server_fd);
    close(epoll_fd);
    return 0;
}

5.3 编译运行

g++ epoll_server.cpp -o epoll_server
./epoll_server

# 多终端并发测试
nc 127.0.0.1 8888

5.4 核心源码解析（面试必考）

1. 全程非阻塞IO

所有fd统一设置为非阻塞，配合ET边缘触发，避免线程阻塞卡死，是高并发的基础。

2. 循环读满缓冲区（ET模式必须）

边缘触发只触发一次，代码中使用while循环读取数据，直到read返回-1，确保缓冲区数据一次性全部读完，杜绝数据残留丢失。

3. 动态注册销毁事件

新连接自动加入监听，客户端断开自动从epoll移除、关闭fd，杜绝文件描述符泄露。

4. 单线程超高并发

全程单线程处理万级连接，无进程线程切换开销，CPU占用极低，并发性能碾压多进程模型。

6. 四大IO模型面试终极总结（满分背诵版）

1. 阻塞IO：简单低效，需要多进程/线程支撑并发，资源开销大，适合低并发场景；

2. 非阻塞IO：轮询空转，极度浪费CPU，生产不用；

3. select/poll多路复用：解决CPU空转，但存在遍历开销、拷贝开销，并发上限有限；

4. epoll多路复用：内核事件回调、无遍历、无上限、低开销、ET极致触发，是Linux高并发服务器的终极方案。

7. 全文总结

我们彻底吃透Linux IO并发核心底层，从操作系统IO两步原理，到四大IO模型逐层对比，再到select/poll/epoll性能拆解，最终手写工业级epoll高并发服务器。

我们彻底解决了传统多进程服务器的并发瓶颈，理解了Nginx、Redis、Web服务器高性能的底层根源，打通了计算机网络 + 操作系统内核 + Linux系统编程的核心壁垒。

核心记忆口诀：IO分两步，阻塞靠等待，非阻塞靠轮询，多路复用靠内核通知，epoll回调封神，ET一次性读满保数据。

本项目为纯正高并发底层内核项目，简历含金量极高，完全区别于普通学生入门级代码。