Linux网络编程- IO多路复用

IO多路复用

IO多路复用是一个非常有用的技术，它允许单个线程/进程同时监视和管理多个IO描述符。它特别适用于那些需要处理大量并发套接字连接的场景，例如Web服务器、数据库服务器或其他网络应用。IO多路复用使得应用程序可以在等待数据时不被阻塞，并在数据到达时立即进行处理。

核心概念

阻塞与非阻塞IO:

• 阻塞IO：应用程序执行IO操作时，必须等待IO操作完成后才能继续执行其他任务。
• 非阻塞IO：应用程序在执行IO操作时可以立即返回，并执行其他任务。如果IO操作没有完成，系统将返回一个错误。

同步与异步IO:

• 同步IO：应用程序发起IO操作后，必须等待或者主动轮询以知道IO操作何时完成。
• 异步IO：应用程序发起IO操作后，系统会在IO操作完成时通知应用程序。

IO多路复用技术

IO多路复用的核心是使用一个系统调用来监视多个文件描述符，看看哪些文件描述符准备好进行读或写操作。有几种主要的IO多路复用技术：

1. select：这是最早的IO多路复用方法，但有其局限性，例如描述符数量的限制。
2. poll：与select相似，但没有描述符数量的限制。
3. epoll：Linux特有的方法，它提供了更好的扩展性，特别是在大量并发连接的情况下。

工作原理

考虑一个网络应用，如Web服务器。在最简单的情况下，服务器每接受一个连接就会创建一个新的进程或线程来处理。但这种方法在高并发的环境下会导致资源极大的浪费。

而IO多路复用的工作原理如下：

1. 一个主线程/进程使用select、poll或epoll等系统调用，来同时监视多个文件描述符。
2. 当其中一个或多个文件描述符准备好进行读或写操作时，系统调用返回。
3. 主线程/进程然后可以对这些准备好的描述符进行IO操作，而不会被阻塞。

优点和限制

优点:

• 能够管理大量的描述符，并且仅使用少量的线程。
• 由于少了线程/进程的切换，因此效率高。
• 可以扩展到非常大的连接数量，特别是使用epoll。

限制:

• 使用IO多路复用技术的程序的编写通常比较复杂。
• 不是所有的操作系统都支持所有的IO多路复用技术，例如epoll只在Linux上可用。

总结

IO多路复用是处理大量并发网络连接的强大技术。尽管其编程复杂度较高，但考虑到其在高并发环境下的性能和效率，它仍然是许多网络应用的首选技术。

select()

select()是一个经典的多路复用I/O函数，用于监控多个文件描述符（通常是套接字描述符）以查看其是否准备好进行读、写或是否有异常条件待处理。其主要应用是在网络编程中，特别是当应用程序需要处理多个并发连接或多个I/O流时。

函数原型

#include 

int select(int nfds, fd_set *readfds, fd_set *writefds,
           fd_set *exceptfds, struct timeval *timeout);

参数解释

• nfds: 用于指定要检查的文件描述符的范围，具体而言，是要检查的最大文件描述符值加1。
• readfds: 一个文件描述符集，应用程序希望知道它们是否准备好读。
• writefds: 一个文件描述符集，应用程序希望知道它们是否准备好写。
• exceptfds: 一个文件描述符集，应用程序希望知道上面是否有异常发生。
• timeout: 指定select()函数等待的最长时间。如果设置为NULL，则函数会一直等待，直到某个描述符准备好。

文件描述符集

fd_set是一个集合数据类型，专门用于select()。以下是与其相关的一些宏：

• FD_ZERO(fd_set *set): 清除文件描述符集。
• FD_SET(int fd, fd_set *set): 将一个文件描述符添加到集合中。
• FD_CLR(int fd, fd_set *set): 从集合中删除一个文件描述符。
• FD_ISSET(int fd, fd_set *set): 检查文件描述符是否在集合中。

返回值

• 返回大于0的值表示准备好的文件描述符数。
• 返回0表示超时，没有任何文件描述符准备好。
• 返回-1表示错误。

工作原理

1. 应用程序设置readfds、writefds和exceptfds来指示select()要监控哪些文件描述符。
2. 应用程序调用select()函数。
3. select()函数会阻塞，直到以下条件之一满足：
   • 有一个文件描述符准备好（读、写或异常）。
   • 超时时间已到。
4. select()返回后，应用程序可以检查readfds、writefds和exceptfds来确定哪些文件描述符已经准备好，并进行相应的操作。

使用select()的优点和缺点

优点:

• 可以处理多个描述符。
• 可以跨平台使用（UNIX/Linux和Windows都支持）。

缺点:

• 所有文件描述符都保存在数组中，效率不高，特别是当描述符数量很大时。
• fd_set大小是固定的，这限制了select()可以处理的最大描述符数量。
• 如果一个描述符准备好，但应用程序没有处理，select()会在下次调用时再次返回这个描述符，可能导致无效的select()唤醒。

尽管如此，select()仍然广泛应用于很多应用程序中，尤其是在早期的网络编程中。现代系统可能更倾向于使用其他的多路复用机制，如poll()、epoll()（Linux）或kqueue()（BSD）。

示例

本例使用select()实现了一个Hello服务器。当客户端连接并发送数据时，无论发送什么请求，服务器都会回应一个简单的 “Hello, World!” HTTP响应。

#include 
#include 
#include 
#include 
#include 
#include 
#include 

#define PORT 8080
#define BUFFER_SIZE 2048
#define MAX_CLIENTS 5

const char *HTTP_RESPONSE = "HTTP/1.1 200 OK\r\n"
                            "Content-Type: text/plain\r\n"
                            "Content-Length: 13\r\n"
                            "Connection: close\r\n\r\n"
                            "Hello, World!";

int main() {
    int server_socket, client_socket, max_sd, sd, activity;
    int client_sockets[MAX_CLIENTS] = {0};
    struct sockaddr_in server_address, client_address;
    socklen_t client_len;
    char buffer[BUFFER_SIZE];
    fd_set read_fds;

    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("Could not create socket");
        exit(1);
    }

    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = INADDR_ANY;
    server_address.sin_port = htons(PORT);

    if (bind(server_socket, (struct sockaddr *)&server_address, sizeof(server_address)) == -1) {
        perror("Bind failed");
        exit(1);
    }

    if (listen(server_socket, 3) == -1) {
        perror("Listen failed");
        exit(1);
    }

    printf("Waiting for connections on port %d...\n", PORT);

    while (1) {
        FD_ZERO(&read_fds);
        FD_SET(server_socket, &read_fds);
        max_sd = server_socket;

        for (int i = 0; i < MAX_CLIENTS; i++) {
            sd = client_sockets[i];
            if (sd > 0)
                FD_SET(sd, &read_fds);
            if (sd > max_sd)
                max_sd = sd;
        }

        activity = select(max_sd + 1, &read_fds, NULL, NULL, NULL);

        if ((activity < 0) && (errno != EINTR)) {
            perror("Select error");
        }

        if (FD_ISSET(server_socket, &read_fds)) {
            client_len = sizeof(client_address);
            client_socket = accept(server_socket, (struct sockaddr *)&client_address, &client_len);
            if (client_socket < 0) {
                perror("Accept error");
                exit(1);
            }

            printf("New connection from %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port));

            for (int i = 0; i < MAX_CLIENTS; i++) {
                if (client_sockets[i] == 0) {
                    client_sockets[i] = client_socket;
                    break;
                }
            }
        }

        for (int i = 0; i < MAX_CLIENTS; i++) {
            sd = client_sockets[i];
            if (FD_ISSET(sd, &read_fds)) {
                int read_size = recv(sd, buffer, sizeof(buffer), 0);
                if (read_size == 0) {
                    getpeername(sd, (struct sockaddr*)&client_address, &client_len);
                    printf("Client disconnected: %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port));

                    close(sd);
                    client_sockets[i] = 0;
                } else {
                    send(sd, HTTP_RESPONSE, strlen(HTTP_RESPONSE), 0);
                    // buffer[read_size] = '\0';
                    // send(sd, buffer, strlen(buffer), 0);
                }
            }
        }
    }

    close(server_socket);
    return 0;
}

此例子创建了一个服务器，使用select()来监视连接请求和客户端的数据。当一个新的客户端连接到服务器时，它将该客户端的套接字加入到客户端套接字数组中。当客户端发送数据时，服务器会返回"Hello, World!" HTTP响应。当客户端断开连接时，它将该客户端的套接字从数组中删除。

另起一个终端，使用curl发送HTTP请求，会看到服务器返回的HTTP响应：

$ curl http://localhost:8080
Hello, World!

poll()

poll()函数是另一个多路复用I/O工具，用于监视多个文件描述符以查看其是否准备好进行读、写或是否有异常条件待处理。与select()相比，poll()提供了更好的可扩展性，尤其是在处理大量文件描述符时。

函数原型

#include 

int poll(struct pollfd *fds, nfds_t nfds, int timeout);

参数解释

• fds: 是一个指向pollfd结构数组的指针，该结构包含了要监视的文件描述符的信息。
• nfds: 是fds数组中的项数。
• timeout: 以毫秒为单位的等待超时。如果为-1，poll()将无限等待。

pollfd结构

该结构定义在头文件中，包含以下字段：

struct pollfd {
    int   fd;         /* 文件描述符 */
    short events;     /* 要监视的事件 */
    short revents;    /* 实际发生的事件 */
};

• fd: 要监视的文件描述符。
• events: 要监视的事件的位掩码。可以是以下值的组合：
  • POLLIN: 数据可读。
  • POLLOUT: 数据可写。
  • POLLERR: 错误条件。
  • POLLHUP: 挂起。
  • POLLNVAL: 描述符不是一个打开的文件。
• revents: 输入/输出参数，当poll()返回时，系统将设置此字段以指示哪些事件实际发生。

返回值

• 如果一个或多个文件描述符准备好，返回准备好的文件描述符数量。
• 如果超时，返回0。
• 如果出错，返回-1。

工作原理

1. 应用程序初始化pollfd结构数组，设置要监控的文件描述符和事件。
2. 应用程序调用poll()函数。
3. poll()函数阻塞，直到以下条件之一满足：
   • 有一个或多个文件描述符准备好。
   • 超时时间已到。
4. poll()返回后，应用程序可以检查pollfd结构中的revents字段，以确定哪些文件描述符已经准备好并进行相应的操作。

poll()的优点和缺点

优点:

• 与select()相比，poll()不受固定大小的文件描述符集的限制。
• poll()提供了更直观的接口，可以明确地为每个文件描述符指定所需的事件。

缺点:

• 在大量文件描述符中，尽管poll()可以处理任意数量的文件描述符，但它必须遍历整个文件描述符列表，这可能导致效率问题。
• 在某些系统中，与更高级的多路复用机制（如Linux的epoll）相比，poll()的性能可能不如它们。

总的来说，poll()提供了一种比select()更灵活的方法来监视文件描述符的多路复用，但在处理大量活跃连接时，可能还需要考虑使用更高级的多路复用技术。

示例

以下是使用poll()的简单例子，这个例子同样是一个HELLO服务器。

#include 
#include 
#include 
#include 
#include 
#include 

#define PORT 8080
#define BUFFER_SIZE 2048
#define MAX_CLIENTS 5

const char *HTTP_RESPONSE = "HTTP/1.1 200 OK\r\n"
                            "Content-Type: text/plain\r\n"
                            "Content-Length: 13\r\n"
                            "Connection: close\r\n\r\n"
                            "Hello, World!";

int main() {
    int server_socket, client_socket;
    struct sockaddr_in server_address, client_address;
    socklen_t client_len;
    char buffer[BUFFER_SIZE];

    struct pollfd fds[MAX_CLIENTS + 1];

    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("Could not create socket");
        exit(1);
    }

    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = INADDR_ANY;
    server_address.sin_port = htons(PORT);

    if (bind(server_socket, (struct sockaddr *)&server_address, sizeof(server_address)) == -1) {
        perror("Bind failed");
        exit(1);
    }

    if (listen(server_socket, 3) == -1) {
        perror("Listen failed");
        exit(1);
    }

    printf("Waiting for connections on port %d...\n", PORT);

    fds[0].fd = server_socket;
    fds[0].events = POLLIN;

    for (int i = 1; i <= MAX_CLIENTS; i++) {
        fds[i].fd = -1;  // initially all clients are -1
    }

    while (1) {
        int activity = poll(fds, MAX_CLIENTS + 1, -1);  // infinite timeout

        if (activity < 0) {
            perror("Poll error");
            continue;
        }

        if (fds[0].revents & POLLIN) {
            client_len = sizeof(client_address);
            client_socket = accept(server_socket, (struct sockaddr *)&client_address, &client_len);

            if (client_socket < 0) {
                perror("Accept error");
                continue;
            }

            printf("New connection from %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port));

            for (int i = 1; i <= MAX_CLIENTS; i++) {
                if (fds[i].fd == -1) {
                    fds[i].fd = client_socket;
                    fds[i].events = POLLIN;
                    break;
                }
            }
        }

        for (int i = 1; i <= MAX_CLIENTS; i++) {
            if (fds[i].fd == -1) continue;

            if (fds[i].revents & POLLIN) {
                int read_size = recv(fds[i].fd, buffer, sizeof(buffer), 0);
                if (read_size == 0) {
                    getpeername(fds[i].fd, (struct sockaddr*)&client_address, &client_len);
                    printf("Client disconnected: %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port));

                    close(fds[i].fd);
                    fds[i].fd = -1;  // mark this client as -1 again
                } else {
                    send(fds[i].fd, HTTP_RESPONSE, strlen(HTTP_RESPONSE), 0);
                    // buffer[read_size] = '\0';
                    // send(fds[i].fd, buffer, strlen(buffer), 0);
                }
            }
        }
    }

    close(server_socket);
    return 0;
}

此代码创建了一个服务器，使用poll()来监视连接请求和来自客户端的数据。当客户端连接到服务器时，它会将其套接字添加到poll()的监视数组中。当客户端发送数据时，服务器会返回"Hello, World!" HTTP响应。当客户端断开连接时，它会将该套接字从监视数组中删除。

另起一个终端，使用curl发送HTTP请求，会看到服务器返回的HTTP响应：

$ curl http://localhost:8080
Hello, World!

epoll()

epoll是Linux特有的I/O多路复用机制，提供了更高效的方式来监视多个文件描述符的活动。与传统的select()和poll()不同，epoll使用一个事件驱动的方式，只返回那些真正活跃的文件描述符，而不是检查每个文件描述符的状态。这使得epoll在处理大量文件描述符时具有很高的效率。

基本概念和函数

1. epoll_create()：创建一个新的epoll实例。

int epoll_create(int size);

虽然这个函数有一个size参数，但在较新的Linux版本中，它实际上并没有用处，只是为了向后兼容。

2. epoll_ctl()：用于向epoll实例中添加、删除或修改监视的文件描述符。

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

• epfd: 由epoll_create()返回的epoll实例的文件描述符。
• op: 操作类型，可以是以下值：EPOLL_CTL_ADD(添加)、EPOLL_CTL_MOD(修改)或EPOLL_CTL_DEL(删除)。
• fd: 要操作的文件描述符。
• event: 指向epoll_event结构的指针，描述了fd上的感兴趣的事件和如何返回它。

3. epoll_wait()：等待epoll实例中的一个或多个文件描述符变得活跃。

int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

• epfd: 由epoll_create()返回的epoll实例的文件描述符。
• events: 用于返回活跃事件的epoll_event结构数组。
• maxevents: events数组的大小。
• timeout: 超时（以毫秒为单位）。-1表示无限等待。

epoll_event结构体

struct epoll_event {
    uint32_t     events;  /* Epoll events */
    epoll_data_t data;    /* User data variable */
};

• events: 是一个位集，指示感兴趣的事件和返回的事件，例如：EPOLLIN、EPOLLOUT、EPOLLERR等。
• data: 是一个联合体，可以包含用户定义的数据，如文件描述符、指针等。

工作原理

1. 创建一个epoll实例。
2. 使用epoll_ctl()向实例中添加或修改文件描述符及其相关的事件。
3. 使用epoll_wait()等待事件发生。
4. 当epoll_wait()返回时，处理活跃的事件。
5. 重复步骤3和4。

优点

1. 可扩展性：与select和poll相比，epoll可以处理大量的并发连接。
2. 效率：epoll只关心活跃的文件描述符，而不是每次都检查所有的文件描述符。
3. 没有固定的限制：与select的FD_SETSIZE限制不同，epoll的限制通常由系统的最大文件描述符数量决定。

缺点

1. Linux特有：epoll是Linux特有的，不可移植到其他UNIX系统或Windows。

总的来说，epoll是Linux下高并发服务器应用的理想选择，它解决了select和poll在大量活跃连接时的性能瓶颈问题。

示例

以下是使用epoll()的简单例子，这个例子还是HELLO服务器。

#include 
#include 
#include 
#include 
#include 
#include 

#define PORT 8080
#define BUFFER_SIZE 2048
#define MAX_EVENTS 10

const char *HTTP_RESPONSE = "HTTP/1.1 200 OK\r\n"
                            "Content-Type: text/plain\r\n"
                            "Content-Length: 13\r\n"
                            "Connection: close\r\n\r\n"
                            "Hello, World!";

int main() {
    int server_socket, client_socket;
    struct sockaddr_in server_address, client_address;
    socklen_t client_len;
    char buffer[BUFFER_SIZE];

    int epoll_fd = epoll_create1(0);
    if (epoll_fd == -1) {
        perror("epoll_create1");
        exit(EXIT_FAILURE);
    }

    server_socket = socket(AF_INET, SOCK_STREAM, 0);
    if (server_socket == -1) {
        perror("Could not create socket");
        exit(1);
    }

    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = INADDR_ANY;
    server_address.sin_port = htons(PORT);

    if (bind(server_socket, (struct sockaddr *)&server_address, sizeof(server_address)) == -1) {
        perror("Bind failed");
        exit(1);
    }

    if (listen(server_socket, 10) == -1) {
        perror("Listen failed");
        exit(1);
    }

    printf("Waiting for connections on port %d...\n", PORT);

    struct epoll_event ev, events[MAX_EVENTS];
    ev.events = EPOLLIN;
    ev.data.fd = server_socket;
    if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_socket, &ev) == -1) {
        perror("epoll_ctl: server_socket");
        exit(EXIT_FAILURE);
    }

    while (1) {
        int nfds = epoll_wait(epoll_fd, events, MAX_EVENTS, -1);
        if (nfds == -1) {
            perror("epoll_wait");
            exit(EXIT_FAILURE);
        }

        for (int n = 0; n < nfds; ++n) {
            if (events[n].data.fd == server_socket) {
                client_socket = accept(server_socket, (struct sockaddr *)&client_address, &client_len);
                if (client_socket == -1) {
                    perror("accept");
                    continue;
                }
                printf("New connection from %s:%d\n", inet_ntoa(client_address.sin_addr), ntohs(client_address.sin_port));
                
                ev.events = EPOLLIN;
                ev.data.fd = client_socket;
                if (epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_socket, &ev) == -1) {
                    perror("epoll_ctl: client_socket");
                    exit(EXIT_FAILURE);
                }
            } else {
                int read_size = recv(events[n].data.fd, buffer, sizeof(buffer), 0);
                if (read_size <= 0) {
                    if (read_size == 0) {  // client disconnected
                        printf("Client disconnected\n");
                    } else {
                        perror("recv");
                    }
                    close(events[n].data.fd);  // close the client socket
                } else {
                    send(events[n].data.fd, HTTP_RESPONSE, strlen(HTTP_RESPONSE), 0);
                    // buffer[read_size] = '\0';
                    // send(events[n].data.fd, buffer, strlen(buffer), 0);
                }
            }
        }
    }

    close(server_socket);
    return 0;
}

此代码创建了一个服务器，使用epoll()来监听连接请求和来自客户端的数据。当客户端连接到服务器时，它会将其套接字添加到epoll()的监视集中。当客户端发送数据时，服务器会返回"Hello, World!" HTTP响应。当客户端断开连接时，服务器会将该套接字从epoll()的监视集中删除。

另起一个终端，使用curl发送HTTP请求，会看到服务器返回的HTTP响应：

$ curl http://localhost:8080
Hello, World!

---

有关curl命令的详细使用，请读者移步到：Linux- curl命令

有关网络编程的常用函数使用方法，请读者移步到：Linux- 网络编程初探