• 《TCP/IP网络编程》阅读笔记--I/O复用

    目录

    1--基于I/O复用的服务器

    2--select()函数

    3--基于I/O复用的回声服务器端

    4--send()和recv()函数的常用可选项

    5--readv()和writev()函数

    1--基于I/O复用的服务器

            多进程服务器端具有以下缺点：当有多个客户端发起连接请求时，就会创建多个进程来分别处理客户端的请求，创建多个进程往往需要付出巨大的代价；

            I/O复用的服务器端可以减少进程数，无论连接多少个客户端，提供服务的进程都只有 1 个；

    2--select()函数

            select() 函数可以将多个文件描述符集中到一起来统一监视，监视文件描述符可以视为监视 socket；集中多个文件描述符时需要按照接收、传输和异常三种情况进行区分；

            select() 通过 fd_set 数组变量来执行监视操作，fd_set 中文件描述符（索引）对应的位（值）被设置为 1 时，表明该文件描述符是监视对象；

    1. // 对 fd_set 数组的常用操作
    2. FD_ZERO(fd_set* fd_set); // 将 fd_set 变量的所有位初始化为0
    3. FD_SET(int fd, fd_set* fdset); // 在参数 fdset 指向的变量中注册文件描述符fd的信息
    4. FD_CLR(int fd, fd_set* fdset); // 从参数 fdset 指向的变量中消除文件描述符fd的信息
    5. FD_ISSET(int fd, fd_set* fdset); // 若参数 fdset 指向的变量中包含文件描述符fd的信息，则返回true

    1. #include 
    2. #include 
    3.  
    4. int select(int maxfd, fd_set* readset, fd_set* writeset, fd_set* exceptset, const struct timeval* timeout);
    5. // 成功时返回大于 0 的值，值为发生事件的文件描述符数；失败时返回 -1；超时返回 0
    6. // maxfd 表示监视对象文件描述符的数量
    7. // readset 表示将所有关注“是否存在待读取数据”的文件描述符注册到fd_set型变量，并传递其地址值
    8. // writeset 表示将所有关注“是否可传输无阻塞数据”的文件描述符注册到fd_set型变量，并传递其地址值
    9. // exceptset 表示将所有关注“是否发生异常”的文件描述符注册到fd_set型变量，并传递其地址值
    10. // timeout 表示调用 select() 函数后，为防止陷入无限阻塞的状态，传递超时信息

            select() 函数只有在监视的文件描述符发生变化时才返回，如果未发生变化就会进入阻塞状态；通过指定超时事件可以防止无限阻塞的情况，即使文件描述符中未发生变化，当超过了指定事件，就会从函数中返回，返回值为 0；

            当调用 select() 函数时，除了发生变化的文件描述符之外，所有原来值为 1 的位均会变为 0，因此可知值仍为 1 的文件描述符发生了变化；

    1. // gcc select.c -o select
    2. // ./select
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7.  
    8. #define BUF_SIZE 30
    9.  
    10. int main(int argc, char* argv[]){
    11.     fd_set reads, temps;
    12.     int result, str_len;
    13.     char buf[BUF_SIZE];
    14.     struct timeval timeout;
    15.  
    16.     FD_ZERO(&reads); // 初始化fd_set变量
    17.     FD_SET(0, &reads); // 将文件描述符 0 对应的位设置为1，表示监视标准输入（文件描述符0对应标准输入stdin）
    18.     
    19.     while(1){
    20.         temps = reads; // 记录初始值，新循环时重新初始化为初始值
    21.         timeout.tv_sec = 5; // 超时时间设置为 5s
    22.         timeout.tv_usec = 0;
    23.         result = select(1, &temps, 0, 0, &timeout); // 5s内监视是否有标准输入时间发生
    24.         if(result == -1){
    25.             puts("select() error!");
    26.             break;
    27.         }
    28.         else if(result == 0){ // 返回值为0表示超时
    29.             puts("Time-out!");
    30.         }
    31.         else{
    32.             if(FD_ISSET(0, &temps)){ // 验证是否是标准输入发生了变化，打印标准输入的内容
    33.                 str_len = read(0, buf, BUF_SIZE);
    34.                 buf[str_len] = 0;
    35.                 printf("message from console: %s", buf);
    36.             }
    37.         }
    38.     }
    39.     return 0;
    40. }

    3--基于I/O复用的回声服务器端

    1. // gcc echo_selectserv.c -o echo_selectserv
    2. // ./echo_selectserv 9190
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11.  
    12. #define BUF_SIZE 100
    13.  
    14. void error_handling(char *buf){
    15.     fputs(buf, stderr);
    16.     fputc('\n', stderr);
    17.     exit(1);
    18. }
    19.  
    20. int main(int argc, char* argv[]){
    21.     int serv_sock, clnt_sock;
    22.     struct sockaddr_in serv_adr, clnt_adr;
    23.     struct timeval timeout;
    24.     fd_set reads, cpy_reads;
    25.  
    26.     socklen_t adr_sz;
    27.     int fd_max, str_len, fd_num, i;
    28.     char buf[BUF_SIZE];
    29.     if(argc != 2){
    30.         printf("Usage : %s \n", argv[0]);
    31.         exit(1);
    32.     }
    33.  
    34.     serv_sock = socket(PF_INET, SOCK_STREAM, 0);
    35.     memset(&serv_adr, 0, sizeof(serv_adr));
    36.     serv_adr.sin_family = AF_INET;
    37.     serv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    38.     serv_adr.sin_port = htons(atoi(argv[1]));
    39.  
    40.     if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr)) == -1){
    41.         error_handling("bind() error"); 
    42.     } 
    43.     if(listen(serv_sock, 5) == -1){
    44.         error_handling("listen() error");
    45.     }
    46.  
    47.     FD_ZERO(&reads); // 初始化fd_set变量
    48.     FD_SET(serv_sock, &reads); // 监视 serv_sock
    49.     fd_max = serv_sock;
    50.  
    51.     while(1){
    52.         cpy_reads = reads; // 记录初始值
    53.         timeout.tv_sec = 5; // 设置超时时间
    54.         timeout.tv_usec = 5000;
    55.  
    56.         if((fd_num = select(fd_max+1, &cpy_reads, 0, 0, &timeout)) == -1){
    57.             break;
    58.         }
    59.         if(fd_num = 0) continue; // 判断是否是超时
    60.         // 真的有事件发生，执行以下代码
    61.         for(i = 0; i < fd_max + 1; i++){
    62.             if(FD_ISSET(i, &cpy_reads)){ // 查找发生状态变化的文件描述符
    63.                 if(i == serv_sock){ // 服务器端socket有变化，执行受理连接请求
    64.                     adr_sz = sizeof(clnt_adr);
    65.                     clnt_sock = accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
    66.                     FD_SET(clnt_sock, &reads); // 将客户端socket注册到fd_set变量中
    67.                     if(fd_max < clnt_sock){
    68.                         fd_max = clnt_sock;
    69.                     }
    70.                     printf("connected client: %d \n", clnt_sock);
    71.                 }
    72.                 else{ // 不是服务器端socket发生变化，表明有要接收的数据
    73.                     str_len = read(i, buf, BUF_SIZE);
    74.                     if(str_len == 0){ // 接收的是 EOF，表明要断开连接
    75.                         FD_CLR(i, &reads);
    76.                         close(i);
    77.                         printf("closed client: %d \n", i);
    78.                     }
    79.                     else{ // 接收的是真实数据
    80.                         write(i, buf, str_len); // 将接收到的数据返回客户端，实现回声功能
    81.                     }
    82.                 }
    83.             }
    84.         }
    85.     }
    86.     close(serv_sock);
    87.     return 0;
    88. }

    4--send()和recv()函数的常用可选项

    1. #include 
    2. ssize_t send(int sockfd, const void* buf, size_t nbytes, int flags);
    3. ssize_t recv(int sockfd, void* buf, size_t nbytes, int flags);
    4. // flags 表示可选项信息

            通常情况下，我们会将 send() 和 recv() 的可选项参数设置为 0，但其实际拥有以下可选项：

    ① MSG_OOB 表示用于传输带外数据（send、recv）

    ② MSG_PEEK 表示验证输入缓冲中是否存在接收的数据（recv）

    ③ MSG_DONTROUTE 表示数据传输过程中不参照路由表，在本地网络中寻找目的地（send）

    ④ MSG_DONTWAIT 表示调用 I/O 函数时不阻塞，用于使用非阻塞 I/O（send、recv）

    ⑤ MSG_WAITALL 表示防止函数返回，直到接收全部请求的字节数（recv）

            MSG_OOB 用于发送带外数据的紧急消息，操作系统收到紧急消息时，将产生 SIGURG 信号，并调用注册的信号处理函数；

    1. // gcc oob_recv.c -o oob_recv
    2. // ./oob_recv 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10. #include 
    11. #include 
    12.  
    13. #define BUF_SIZE 30
    14. int acpt_sock;
    15. int recv_sock;
    16.  
    17. void error_handling(char *message){
    18.     fputs(message, stderr);
    19.     fputc('\n', stderr);
    20.     exit(1);
    21. }
    22.  
    23. void urg_handler(int signo){
    24.     int str_len;
    25.     char buf[BUF_SIZE];
    26.     str_len = recv(recv_sock, buf, sizeof(buf) - 1, MSG_OOB);
    27.     buf[str_len] = 0;
    28.     printf("Urgent message: %s \n", buf);
    29. }
    30.  
    31. int main(int argc, char* argv[]){
    32.     struct sockaddr_in recv_adr, serv_adr;
    33.     int str_len, state;
    34.     socklen_t serv_adr_sz;
    35.     struct sigaction act;
    36.     char buf[BUF_SIZE];
    37.  
    38.     if(argc != 2){
    39.         printf("Usage : %s \n", argv[0]);
    40.         exit(1);
    41.     }
    42.  
    43.     act.sa_handler = urg_handler; //设置信号的处理函数
    44.     sigemptyset(&act.sa_mask);
    45.     act.sa_flags = 0;
    46.  
    47.     acpt_sock = socket(PF_INET, SOCK_STREAM, 0);
    48.     memset(&recv_adr, 0, sizeof(recv_adr));
    49.     recv_adr.sin_family = AF_INET;
    50.     recv_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    51.     recv_adr.sin_port = htons(atoi(argv[1]));
    52.  
    53.     if(bind(acpt_sock, (struct sockaddr*) &recv_adr, sizeof(recv_adr)) == -1){
    54.         error_handling("bind() error"); 
    55.     }
    56.     listen(acpt_sock, 5); 
    57.  
    58.     serv_adr_sz = sizeof(serv_adr);
    59.     recv_sock = accept(acpt_sock, (struct sockaddr*)&serv_adr, &serv_adr_sz);
    60.  
    61.     // getpid() 返回进程ID
    62.     // recv_sock发生SIGUGR信号，需要有确定的处理进程（假设创建了多个进程）来调用信号处理函数
    63.     // fcntl() 将 getpid() 返回的进程作为 SIGUGR 信号的处理进程
    64.     fcntl(recv_sock, F_SETOWN, getpid());
    65.  
    66.     state = sigaction(SIGURG, &act, 0); // 发生SIGURG信号时，调用urg_handler()函数
    67.  
    68.     while((str_len = recv(recv_sock, buf, sizeof(buf)-1, 0)) != 0){
    69.         if(str_len == -1){
    70.             continue;
    71.         }
    72.         buf[str_len] = 0;
    73.         puts(buf);
    74.     }
    75.     close(recv_sock);
    76.     close(acpt_sock);
    77.     return 0;
    78. }
    79.  
    1. // gcc oob_send.c -o oob_send
    2. // ./oob_send 127.0.0.1 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define BUF_SIZE 30
    12.  
    13. void error_handling(char *message){
    14.     fputs(message, stderr);
    15.     fputc('\n', stderr);
    16.     exit(1);
    17. }
    18.  
    19. int main(int argc, char *argv[]){
    20.     int sock;
    21.     struct sockaddr_in recv_adr;
    22.     if(argc != 3){
    23.         printf("Usage : %s  \n", argv[0]);
    24.         exit(1);
    25.     }
    26.  
    27.     sock = socket(PF_INET, SOCK_STREAM, 0);
    28.     memset(&recv_adr, 0, sizeof(recv_adr));
    29.     recv_adr.sin_family = AF_INET;
    30.     recv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    31.     recv_adr.sin_port = htons(atoi(argv[2]));
    32.  
    33.     if(connect(sock, (struct sockaddr*)&recv_adr, sizeof(recv_adr)) == -1){
    34.         error_handling("connect() error!");
    35.     }
    36.  
    37.     write(sock, "123", strlen("123")); 
    38.     send(sock, "4", strlen("4"), MSG_OOB); // 紧急传输数据
    39.     write(sock, "567", strlen("567"));
    40.     send(sock, "890", strlen("890"), MSG_OOB); // 紧急传输数据
    41.     close(sock);
    42.     return 0;
    43. }

            同时设置 MSG_PEEK 选项和 MSG_DONTWAIT 选项，可以验证输入缓冲中是否存在接收的数据，同时由于设置了 MSG_PEEK 选项，则调用 recv 函数时，即使读取了输入缓冲的数据也不会删除输入缓冲的数据（也就是说下一次读取时，还可以读到上一次读取的数据）；

    1. // gcc peek_recv.c -o peek_recv
    2. // ./peek_recv 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. #define BUF_SIZE 30
    12.  
    13. void error_handling(char *message){
    14.     fputs(message, stderr);
    15.     fputc('\n', stderr);
    16.     exit(1);
    17. }
    18.  
    19. int main(int argc, char* argv[]){
    20.     int acpt_sock, recv_sock;
    21.     struct sockaddr_in acpt_adr, recv_adr;
    22.     int str_len, state;
    23.     socklen_t recv_adr_sz;
    24.     char buf[BUF_SIZE];
    25.     if(argc != 2){
    26.         printf("Usage : %s \n", argv[0]);
    27.         exit(1);
    28.     }
    29.  
    30.     acpt_sock = socket(PF_INET, SOCK_STREAM, 0);
    31.     memset(&acpt_adr, 0, sizeof(acpt_adr));
    32.     acpt_adr.sin_family = AF_INET;
    33.     acpt_adr.sin_addr.s_addr = htonl(INADDR_ANY);
    34.     acpt_adr.sin_port = htons(atoi(argv[1]));
    35.  
    36.     if(bind(acpt_sock, (struct sockaddr*) &acpt_adr, sizeof(acpt_adr)) == -1){
    37.         error_handling("bind() error"); 
    38.     }
    39.     listen(acpt_sock, 5); 
    40.  
    41.     recv_adr_sz = sizeof(recv_adr);
    42.     recv_sock = accept(acpt_sock, (struct sockaddr*)&recv_adr, &recv_adr_sz);
    43.  
    44.     while(1){
    45.         // 设置 MSG_PEEK|MSG_DONTWAIT 选项，即使不存在待读取的数据，也不会进入阻塞状态
    46.         // 假设存在待读取的数据，则读取且不删除输入缓冲的数据，因此下次仍可以读取
    47.         str_len = recv(recv_sock, buf, sizeof(buf) - 1, MSG_PEEK|MSG_DONTWAIT);
    48.         if(str_len > 0){
    49.             break;
    50.         }
    51.     }
    52.     buf[str_len] = 0;
    53.     printf("Buffering %d bytes: %s \n", str_len, buf);
    54.     // 读取上一次留在输入缓冲的数据
    55.     str_len = recv(recv_sock, buf, sizeof(buf) - 1, 0);
    56.     buf[str_len] = 0;
    57.     printf("Read again: %s \n", buf);
    58.     close(acpt_sock);
    59.     close(recv_sock);
    60.     return 0;
    61. }
    1. // gcc peek_send.c -o peek_send
    2. // ./peek_send 127.0.0.1 9190
    3.  
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. #include 
    10.  
    11. void error_handling(char *message){
    12.     fputs(message, stderr);
    13.     fputc('\n', stderr);
    14.     exit(1);
    15. }
    16.  
    17. int main(int argc, char *argv[]){
    18.     int sock;
    19.     struct sockaddr_in recv_adr;
    20.     if(argc != 3){
    21.         printf("Usage : %s  \n", argv[0]);
    22.         exit(1);
    23.     }
    24.  
    25.     sock = socket(PF_INET, SOCK_STREAM, 0);
    26.     memset(&recv_adr, 0, sizeof(recv_adr));
    27.     recv_adr.sin_family = AF_INET;
    28.     recv_adr.sin_addr.s_addr = inet_addr(argv[1]);
    29.     recv_adr.sin_port = htons(atoi(argv[2]));
    30.  
    31.     if(connect(sock, (struct sockaddr*)&recv_adr, sizeof(recv_adr)) == -1){
    32.         error_handling("connect() error!");
    33.     }
    34.  
    35.     write(sock, "123", strlen("123"));
    36.     close(sock);
    37.     return 0;
    38. }

    5--readv()和writev()函数

            readv() 和 writev() 函数对数据进行整合后，再进行读取和发送；即通过 writev() 函数可以将分散保存在多个缓冲中的数据一并发送，通过 readv() 函数可以由多个缓冲分别接收；

    1. #include 
    2.  
    3. ssize_t writev(int filedes, const struct iovec* iov, int iovcnt);
    4. // 成功时返回发送的字节数，失败时返回 -1
    5. // filedes 表示文件描述符
    6. // iov 表示 iovec 结构体数组的地址值
    7. // iovcnt 表示向第二个参数传递的数组长度
    8.  
    9. ssize_t readv(int filedes, const struct iovec* iov, int iovcnt);
    10. // 成功时返回接收的字节数，失败时返回 -1
    11.  
    12. // iovec结构体
    13. struct iovec{
    14.     void* iov_base; // 缓冲地址
    15.     size_t iov_len; // 缓冲大小
    16. }

    代码实例：

    1. // gcc writev.c -o write
    2. // ./write
    3.  
    4. #include 
    5. #include 
    6.  
    7. int main(int argc, char* argv[]){
    8.     struct iovec vec[2];
    9.     char buf1[] = "ABCDEFG";
    10.     char buf2[] = "1234567";
    11.     int str_len;
    12.  
    13.     vec[0].iov_base = buf1;
    14.     vec[0].iov_len = 3; 
    15.     vec[1].iov_base = buf2;
    16.     vec[1].iov_len = 4;
    17.  
    18.     str_len = writev(1, vec, 2); // 向文件描述符1写数据，即向标准输出写数据
    19.     puts("");
    20.     printf("Write bytes: %d \n", str_len);
    21.     return 0;
    22. }

    1. // gcc readv.c -o readv
    2. // ./readv
    3.  
    4. #include 
    5. #include 
    6.  
    7. #define BUF_SIZE 100
    8.  
    9. int main(int argc, char *argv[]){
    10.     struct iovec vec[2];
    11.     char buf1[BUF_SIZE] = {0,};
    12.     char buf2[BUF_SIZE] = {0,};
    13.     int str_len;
    14.  
    15.     vec[0].iov_base = buf1;
    16.     vec[0].iov_len = 5; // 设置最多保存5个字节
    17.     vec[1].iov_base = buf2;
    18.     vec[1].iov_len = BUF_SIZE;
    19.  
    20.     str_len = readv(0, vec, 2); // 向标准输入（文件描述符0）读数据
    21.     printf("Read bytes: %d \n", str_len);
    22.     printf("First message: %s \n", buf1);
    23.     printf("Second message: %s \n", buf2);
    24.     return 0;
    25. }

  • 相关阅读:
    [MySQL]存储过程与函数
    Pimpl 与 unique_ptr 的问题
    Android 12之启动画面Splash Screens（二） -- framework原理
    2022最新Java面试笔试题目分享，Java高级工程师面试题
    双指针--浅试
    三数之和（LeetCode 15）
    PD虚拟机（Parallels Desktop）2024mac苹果电脑19免费版下载
    ARM day9
    详解单例模式
    栈的概念及用法
  • 原文地址：https://blog.csdn.net/weixin_43863869/article/details/132794581