网络IO与IO多路复用

一、网络IO基础

• 系统对象：
  • 网络IO涉及用户空间调用IO的进程或线程以及内核空间的内核系统。
  • 例如，当进行read操作时，会经历两个阶段：
    1. 等待数据准备就绪。
    2. 将数据从内核拷贝到进程或线程中。
• 多种网络IO模型的出现原因：由于上述两个阶段的不同情况，出现了多种网络IO模型。

二、阻塞IO（blocking IO）

• 特点：
  • 在Linux中，默认所有socket都是阻塞的。
  • 以读操作为例，当用户进程调用read系统调用，kernel开始IO的第一阶段（准备数据），对于网络IO，数据可能未到，kernel要等待，用户进程会被阻塞。
  • 直到kernel等到数据准备好，将数据从kernel拷贝到用户内存并返回结果，用户进程才解除阻塞状态。
  • 即阻塞IO在等待数据和拷贝数据两个阶段都阻塞进程。
  • 例如，使用listen()、send()、recv()等接口构建服务器/客户机模型，这些接口大多是阻塞型的。
  • 代码示例：

// 创建服务器端的socket
int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
// 绑定地址
struct sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(8080);
serverAddr.sin_addr.s_addr = INADDR_ANY;
bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
// 监听连接
listen(serverSocket, 5);
// 接受连接
int clientSocket = accept(serverSocket, NULL, NULL);
// 接收数据，在此处进程会阻塞，直到接收到数据或出错
char buffer[1024];
recv(clientSocket, buffer, sizeof(buffer), 0);
// 发送数据，在此处进程也可能阻塞
send(clientSocket, buffer, strlen(buffer), 0);

- 解释：上述代码首先创建了一个服务器端的socket，然后绑定地址和端口，接着监听连接。当调用`accept`时，如果没有连接请求，会阻塞等待。一旦有连接，调用`recv`接收数据时，会阻塞直到有数据到达。发送数据时也可能阻塞，例如网络拥堵或接收方接收缓冲区满。

• 多线程/多进程改进方案：
  • 为解决单个连接阻塞影响其他连接的问题，可在服务器端使用多线程或多进程。
  • 多线程可使用pthread_create()创建，多进程使用fork()创建。
  • 多线程开销相对小，适合为较多客户机服务；进程更安全，适合单个服务执行体需要大量CPU资源的情况。
  • 例如，服务器端为多个客户机提供服务时，可在主线程等待连接请求，有连接时创建新线程或新进程提供服务。
  • 但当需要同时响应大量（成百上千）连接请求时，多线程或多进程会严重占用系统资源，导致系统效率下降和假死。

三、非阻塞IO（non-blocking IO）

• 特点：
  • 通过设置socket为非阻塞，如使用fcntl( fd, F_SETFL, O_NONBLOCK );。
  • 当用户进程发出read操作，若kernel数据未准备好，不会阻塞用户进程，而是立即返回error。
  • 用户进程可根据返回结果判断数据是否准备好，未准备好可再次发送read操作。
  • 当数据准备好，kernel会将数据拷贝到用户内存并返回。
  • 例如，recv()接口在非阻塞状态下调用后立即返回，返回值有不同含义：
    • recv()返回值大于 0，表示接受数据完毕，返回值是接收到的字节数。
    • recv()返回 0，表示连接正常断开。
    • recv()返回 -1，且errno等于EAGAIN，表示recv操作未完成。
    • recv()返回 - 1，且errno不等于EAGAIN，表示recv操作遇到系统错误errno。
  • 代码示例：

// 创建服务器端的socket
int serverSocket = socket(AF_INET, SOCK_STREAM, 0);
// 设置为非阻塞
fcntl(serverSocket, F_SETFL, O_NONBLOCK);
// 绑定地址
struct sockaddr_in serverAddr;
serverAddr.sin_family = AF_INET;
serverAddr.sin_port = htons(8080);
serverAddr.sin_addr.s_addr = INADDR_ANY;
bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr));
// 监听连接
listen(serverSocket, 5);
// 接受连接
int clientSocket = accept(serverSocket, NULL, NULL);
// 接收数据，此处不会阻塞，会根据返回值判断状态
char buffer[1024];
int recvResult;
while ((recvResult = recv(clientSocket, buffer, sizeof(buffer), 0)) == -1 && errno == EAGAIN) {// 数据未准备好，可进行其他操作或再次尝试接收
}
if (recvResult > 0) {// 处理接收到的数据
} else if (recvResult == 0) {// 连接断开
} else {// 其他错误
}

- 解释：在这个示例中，将服务器端socket设置为非阻塞后，调用`recv`时不会阻塞进程。如果`recv`返回-1且`errno`为`EAGAIN`，说明数据还未准备好，程序可继续执行其他操作或过段时间再尝试接收，而不是像阻塞IO那样一直等待。

四、多路复用IO（IO multiplexing）

• 特点：
  • 又称事件驱动IO(event driven IO)，如select/epoll。
  • 单个进程可同时处理多个网络连接的IO，基本原理是select/epoll函数不断轮询所负责的所有socket，当某个socket有数据到达，通知用户进程。
  • 流程：用户进程调用select会被阻塞，kernel监视select负责的socket，当有socket数据准备好，select返回，用户进程再调用read操作将数据从kernel拷贝到用户进程。
  • 虽然使用select需要两个系统调用（select和read），但优势是可在一个线程内处理多个socket的IO请求。
  • 代码示例：

#include <stdio.h>
#include <sys/select.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>int main() {int serverSocket = socket(AF_INET, SOCK_STREAM, 0);struct sockaddr_in serverAddr;serverAddr.sin_family = AF_INET;serverAddr.sin_port = htons(8080);serverAddr.sin_addr.s_addr = INADDR_ANY;bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr));listen(serverSocket, 5);fd_set readfds;FD_ZERO(&readfds);FD_SET(serverSocket, &readfds);int maxFd = serverSocket;while (1) {fd_set tempFds = readfds;int activity = select(maxFd + 1, &tempFds, NULL, NULL, NULL);if (FD_ISSET(serverSocket, &tempFds)) {int clientSocket = accept(serverSocket, NULL, NULL);FD_SET(clientSocket, &readfds);if (clientSocket > maxFd) {maxFd = clientSocket;}}for (int i = 0; i <= maxFd; i++) {if (FD_ISSET(i, &tempFds) && i!= serverSocket) {char buffer[1024];int valread = recv(i, buffer, 1024, 0);if (valread == 0) {close(i);FD_CLR(i, &readfds);} else {// 处理接收到的数据}}}}return 0;
}

- 解释：首先创建服务器socket，绑定并监听。`FD_ZERO`和`FD_SET`用于初始化和设置文件描述符集合。`select`函数会阻塞，等待集合中文件描述符的可读事件。当`serverSocket`有新连接时，添加新连接的socket到集合，并更新最大文件描述符。当其他socket可读时，接收数据并处理。

• 接口原型：
  • FD_ZERO(int fd, fd_set* fds)：初始化fd_set。
  • FD_SET(int fd, fd_set* fds)：将句柄添加到fd_set。
  • FD_ISSET(int fd, fd_set* fds)：检查句柄是否在fd_set中。
  • FD_CLR(int fd, fd_set* fds)：从fd_set中移除句柄。
  • int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout)：用于探测多个文件句柄的状态变化，readfds、writefds和exceptfds作为输入和输出参数，可设置超时时间。
• 问题：
  • 当需要探测的句柄值较大时，select()接口本身需要大量时间轮询，很多操作系统提供更高效接口如epoll（Linux）、kqueue（BSD）、/dev/poll（Solaris）等。
  • 该模型将事件探测和事件响应夹杂，若事件响应执行体庞大，会降低事件探测的及时性。
  • 可使用事件驱动库如libevent、libev库解决上述问题。

五、异步IO（Asynchronous I/O）

• 特点：
  • Linux下的异步IO主要用于磁盘IO读写操作，从内核2.6版本开始引入。
  • 用户进程发起read操作后可做其他事，kernel收到asynchronous read后立刻返回，不会阻塞用户进程。
  • kernel等待数据准备完成，将数据拷贝到用户内存，完成后给用户进程发送信号通知。
  • 代码示例（使用aio_read）：

#include <aio.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>void aio_completion_handler(union sigval sigval) {struct aiocb *req = (struct aiocb *)sigval.sival_ptr;if (aio_error(req) == 0) {char *buffer = (char *)malloc(aio_return(req));// 处理读取到的数据free(buffer);}aio_destroy(req);
}int main() {int fd = open("test.txt", O_RDONLY);if (fd < 0) {perror("open");return 1;}struct aiocb my_aiocb;memset(&my_aiocb, 0, sizeof(struct aiocb));my_aiocb.aio_fildes = fd;my_aiocb.aio_buf = malloc(1024);my_aiocb.aio_nbytes = 1024;my_aiocb.aio_offset = 0;my_aiocb.aio_sigevent.sigev_notify = SIGEV_THREAD;my_aiocb.aaiocb.sigev_notify_function = aio_completion_handler;my_aiocb.aio_sigevent.sigev_notify_attributes = NULL;my_aiocb.aio_sigevent.sigev_value.sival_ptr = &my_aiocb;if (aio_read(&my_aiocb) < 0) {perror("aio_read");close(fd);return 1;}// 进程可做其他事情sleep(1);return 0;
}

- 解释：上述代码使用`aio_read`进行异步读操作。首先打开文件，设置`aiocb`结构（包含文件描述符、缓冲区、字节数等），并设置信号通知方式和处理函数。调用`aio_read`后，进程可以继续做其他事情，当读操作完成，会调用`aio_completion_handler`处理结果。

• 重要性：异步IO是真正非阻塞的，对高并发网络服务器实现至关重要。

六、信号驱动IO（signal driven I/O， SIGIO）

• 特点：
  • 允许套接口进行信号驱动I/O并安装信号处理函数，进程继续运行不阻塞。
  • 当数据准备好，进程收到SIGIO信号，可在信号处理函数中调用I/O操作函数处理数据。
  • 优势在于等待数据报到达期间，进程可继续执行，避免了select的阻塞与轮询。

七、服务器模型Reactor与Proactor

• Reactor模型：
  • 是一种事件驱动机制，用于同步I/O。
  • 应用程序将处理I/O事件的接口注册到Reactor上，若相应事件发生，Reactor调用注册的接口（回调函数）。
  • 三个重要组件：
    1. 多路复用器：如select、poll、epoll等系统调用。
    2. 事件分发器：将多路复用器返回的就绪事件分到对应的处理函数。
    3. 事件处理器：负责处理特定事件的处理函数。
  • 具体流程：
    1. 注册读就绪事件和相应事件处理器。
    2. 事件分离器等待事件。
    3. 事件到来，激活分离器，分离器调用事件对应的处理器。
    4. 事件处理器完成实际的读操作，处理数据，注册新事件，返还控制权。
  • 优点：响应快，编程相对简单，可扩展性和可复用性好。
  • 缺点：当程序需要使用多核资源时会有局限，因为通常是单线程的。
  • 代码示例：

#include <iostream>
#include <sys/epoll.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>class EventHandler {
public:virtual void handleEvent(int fd) = 0;
};class Reactor {
private:int epollFd;std::vector<EventHandler*> handlers;
public:Reactor() {epollFd = epoll_create1(0);}~Reactor() {close(epollFd);}void registerHandler(int fd, EventHandler* handler) {struct epoll_event event;event.data.fd = fd;event.events = EPOLLIN;epoll_ctl(epollFd, EPOLL_CTL_ADD, fd, &event);handlers.push_back(handler);}void handleEvents() {struct epoll_event events[10];int numEvents = epoll_wait(epollFd, events, 10, -1);for (int i = 0; i < numEvents; i++) {int fd = events[i].data.fd;for (EventHandler* handler : handlers) {handler->handleEvent(fd);}}}
};class EchoHandler : public EventHandler {
public:void handleEvent(int fd) override {char buffer[1024];int bytesRead = recv(fd, buffer, sizeof(buffer), 0);if (bytesRead > 0) {send(fd, buffer, bytesRead, 0);}}
};int main() {Reactor reactor;int serverSocket = socket(AF_INET, SOCK_STREAM, 0);struct sockaddr_in serverAddr;serverAddr.sin_family = AF_INET;serverAddr.sin_port = htons(8080);serverAddr.sin_addr.s_addr = INADDR_ANY;bind(serverSocket, (struct sockaddr*)&serverAddr, sizeof(serverAddr));listen(serverSocket, 5);EchoHandler handler;reactor.registerHandler(serverSocket, &handler);while (1) {reactor.handleEvents();}return 0;
}

- 解释：上述C++代码中，`Reactor`类负责创建`epoll`，注册和处理事件。`EventHandler`是抽象基类，`EchoHandler`是具体处理接收和发送的派生类。`main`函数创建服务器socket，注册`EchoHandler`到`Reactor`，并不断调用`handleEvents`处理事件。

• Proactor模型：
  • 最大特点是使用异步I/O，所有I/O操作都交由系统的异步I/O接口执行，工作线程只负责业务逻辑。
  • 具体流程：
    1. 处理器发起异步操作并关注I/O完成事件。
    2. 事件分离器等待操作完成事件。
    3. 分离器等待时，内核并行执行实际I/O操作并将结果存入用户缓冲区，通知分离器读操作完成。
    4. I/O完成后，通过事件分离器呼唤处理器。
    5. 事件处理器处理用户缓冲区中的数据。
  • 增加了编程复杂度，但给工作线程带来更高效率，可利用系统态的读写优化。
  • 在Windows上常用IOCP支持高并发，Linux上因aio性能不佳，主要以Reactor模型为主。
  • 也可使用Reactor模拟Proactor，但在读写并行能力上会有区别。

八、同步I/O和异步I/O的区别总结

• 阻塞与非阻塞IO的区别：
  • 调用阻塞IO会阻塞进程直到操作完成，非阻塞IO在kernel准备数据时会立刻返回。
• 同步与异步IO的区别：
  • 同步IO在做“IO operation”（如read系统调用）时会阻塞进程。阻塞IO、非阻塞IO、多路复用IO都属于同步IO。
  • 非阻塞IO在数据准备好时的拷贝数据阶段会阻塞进程；而异步IO在整个过程中，进程不会被阻塞，进程发起IO操作后直接做其他事，直到kernel发送信号通知完成。