• 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);

    • 1
    • 2
    • 3
    • 4

    参数解释

    • 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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107

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

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

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

    • 1
    • 2

    poll()

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

    函数原型

    #include 

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

    • 1
    • 2
    • 3

    参数解释

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

    pollfd结构

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

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

    • 1
    • 2
    • 3
    • 4
    • 5
    • 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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105

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

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

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

    • 1
    • 2

    epoll()

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

    基本概念和函数

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

    • 1

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

    1. epoll_ctl()：用于向epoll实例中添加、删除或修改监视的文件描述符。
    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

    • 1
    • epfd: 由epoll_create()返回的epoll实例的文件描述符。
    • op: 操作类型，可以是以下值：EPOLL_CTL_ADD(添加)、EPOLL_CTL_MOD(修改)或EPOLL_CTL_DEL(删除)。
    • fd: 要操作的文件描述符。
    • event: 指向epoll_event结构的指针，描述了fd上的感兴趣的事件和如何返回它。
    1. epoll_wait()：等待epoll实例中的一个或多个文件描述符变得活跃。
    int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

    • 1
    • 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 */
};

    • 1
    • 2
    • 3
    • 4
    • 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;
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102

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

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

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

    • 1
    • 2

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

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

  • 相关阅读:
    作为测试工程师的发展之路-如何做好测试开开发？
    [JavaScript 刷题] 树 - 二叉搜索树迭代器, leetcode 173
    操作系统的发展
    北理工嵩天Python语言程序设计笔记（7 组合数据类型）
    GO-日志分析
    CARLA和LGSVL坐标系差异
    Android Root全教程
    nyoj 题目287 Radar 贪心算法
    idea常用快捷键 idea搜索快捷键
    麦芽糖-链霉亲和素maltose-Streptavidins链霉亲和素-PEG-麦芽糖
  • 原文地址：https://blog.csdn.net/weixin_43844521/article/details/133976545