1. C++网络编程模型详解

C++作为高性能系统编程语言，在网络编程领域有着广泛的应用。从传统的阻塞I/O到现代的非阻塞异步模型，C++网络编程经历了多个发展阶段。本文将系统梳理C++中常见的网络编程模型，帮助读者理解不同模型的适用场景和实现要点。

2. 阻塞I/O模型

阻塞I/O是最传统的网络编程模型。在这种模型下，当应用程序调用recv()、accept()等系统调用时，如果数据尚未就绪，调用线程会被挂起，直到数据到达或发生错误才返回。

// 阻塞I/O示例
SOCKET sock = socket(AF_INET, SOCK_STREAM, 0);
bind(sock, ...);
listen(sock, 5);

while (true) {
    SOCKET client = accept(sock, nullptr, nullptr);  // 阻塞等待连接
    char buf[1024];
    int n = recv(client, buf, sizeof(buf), 0);       // 阻塞等待数据
    // 处理数据...
    closesocket(client);
}

优点：编程简单直观，逻辑清晰。缺点：每个连接需要一个独立线程，并发量大时线程开销巨大。

3. 多线程/多进程模型

为了解决阻塞I/O无法处理多连接的缺陷，出现了多线程/多进程模型。主线程负责监听和接受连接，每个新连接由独立的线程或进程处理。

// 多线程模型示例
void handle_client(SOCKET client) {
    char buf[1024];
    while (true) {
        int n = recv(client, buf, sizeof(buf), 0);
        if (n <= 0) break;
        send(client, buf, n, 0);
    }
    closesocket(client);
}

int main() {
    SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, 0);
    bind(listen_sock, ...);
    listen(listen_sock, 5);

    while (true) {
        SOCKET client = accept(listen_sock, nullptr, nullptr);
        std::thread(handle_client, client).detach();  // 每个连接一个线程
    }
}

优点：编程相对简单，能处理多连接。缺点：线程创建销毁开销大，高并发下上下文切换频繁，资源占用高。

4. I/O多路复用模型

I/O多路复用通过select、poll、epoll（Linux）或kqueue（macOS/FreeBSD）等系统调用，让单个线程同时监视多个文件描述符的I/O事件。

4.1 select/poll

// select模型示例
fd_set readfds;
FD_ZERO(&readfds);
FD_SET(listen_sock, &readfds);

while (true) {
    fd_set tmp = readfds;
    int ret = select(max_fd + 1, &tmp, nullptr, nullptr, nullptr);
    if (FD_ISSET(listen_sock, &tmp)) {
        // 处理新连接
    }
    // 遍历所有fd检查可读数据
}

select的缺点：最大文件描述符数量受限（通常1024），每次调用需要重新设置fd_set，性能随连接数增加线性下降。

4.2 epoll（Linux高性能方案）

// epoll边缘触发（ET）模式示例
int epfd = epoll_create1(0);
struct epoll_event ev, events[1024];
ev.events = EPOLLIN | EPOLLET;  // 边缘触发
ev.data.fd = listen_sock;
epoll_ctl(epfd, EPOLL_CTL_ADD, listen_sock, &ev);

while (true) {
    int nfds = epoll_wait(epfd, events, 1024, -1);
    for (int i = 0; i < nfds; ++i) {
        if (events[i].data.fd == listen_sock) {
            // 处理新连接，并设置为非阻塞
        } else {
            // 循环读取数据直到EAGAIN
        }
    }
}

epoll的优势：支持大量连接（百万级），仅返回就绪的fd，无需遍历全部。边缘触发模式配合非阻塞I/O能获得最佳性能。

5. Reactor模型

Reactor模型是事件驱动架构的经典实现，它将I/O事件分发与业务处理解耦。核心组件包括：事件多路分发器（Demultiplexer）、事件处理器（EventHandler）和Reactor调度器。

// 简化版Reactor框架
class EventHandler {
public:
    virtual void handle_read() = 0;
    virtual void handle_write() = 0;
    virtual int get_fd() = 0;
};

class Reactor {
    std::map<int, EventHandler*> handlers;
    int epfd;
public:
    void register_handler(EventHandler* h) {
        struct epoll_event ev;
        ev.events = EPOLLIN | EPOLLET;
        ev.data.ptr = h;
        epoll_ctl(epfd, EPOLL_CTL_ADD, h->get_fd(), &ev);
        handlers[h->get_fd()] = h;
    }
    void event_loop() {
        struct epoll_event events[1024];
        while (true) {
            int nfds = epoll_wait(epfd, events, 1024, -1);
            for (int i = 0; i < nfds; ++i) {
                auto* h = static_cast<EventHandler*>(events[i].data.ptr);
                if (events[i].events & EPOLLIN) h->handle_read();
                if (events[i].events & EPOLLOUT) h->handle_write();
            }
        }
    }
};

Reactor模型广泛应用于Redis、Netty、Nginx等高性能网络框架中，是C++网络编程的核心设计模式之一。

6. Proactor模型

Proactor模型是异步I/O的典型实现。与Reactor不同，Proactor由操作系统完成实际的I/O操作，完成后通知应用程序。在Windows上通过IOCP实现，Linux的和io_uring也提供了类似能力。

// Windows IOCP示例（简化）
HANDLE iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
CreateIoCompletionPort((HANDLE)sock, iocp, (ULONG_PTR)key, 0);

// 投递异步读操作
WSABUF buf;
buf.buf = buffer;
buf.len = sizeof(buffer);
DWORD flags = 0;
WSARecv(sock, &buf, 1, nullptr, &flags, &overlapped, nullptr);

// 等待完成
DWORD bytes;
ULONG_PTR key;
LPOVERLAPPED overlapped;
GetQueuedCompletionStatus(iocp, &bytes, &key, &overlapped, INFINITE);

Proactor的优势：I/O操作完全异步，线程利用率更高。缺点：编程复杂度高，跨平台实现差异大。

7. 协程模型（C++20）

C++20引入了协程（Coroutines）支持，使得异步代码可以像同步代码一样编写，大幅降低了异步编程的复杂度。

// C++20协程网络编程示例（概念性）
Task<void> echo_server(SOCKET client) {
    char buf[1024];
    while (true) {
        int n = co_await async_recv(client, buf, sizeof(buf));
        if (n <= 0) break;
        co_await async_send(client, buf, n);
    }
    closesocket(client);
}

Task<void> server() {
    SOCKET listen_sock = ...;
    while (true) {
        SOCKET client = co_await async_accept(listen_sock);
        co_spawn(echo_server(client));  // 启动协程处理
    }
}

协程模型结合了同步编程的简洁性和异步编程的高性能，是C++网络编程的未来趋势。

8. 模型对比与选型建议

模型	并发能力	编程复杂度	CPU利用率	适用场景
阻塞I/O	低	低	低	简单工具、低并发服务
多线程	中	中	中	中小型服务、连接数有限
I/O多路复用	高	中	高	高并发网关、聊天服务器
Reactor	高	中高	高	通用高性能服务器
Proactor/IOCP	极高	高	极高	Windows高性能服务、文件服务器
协程	高	中	高	现代C++项目、异步业务逻辑

C++网络编程模型从阻塞I/O到协程，经历了不断演进的过程。在实际项目中，应根据业务场景、操作系统平台和团队技术栈选择合适的模型：

• Linux平台优先考虑epoll + Reactor模式
• Windows平台可充分利用IOCP
• 新项目可尝试C++20协程，降低异步编程心智负担
• 高性能场景可关注io_uring等新型异步I/O接口

理解这些模型的原理和适用边界，是构建高性能C++网络应用的基础。