devbox
知新_RL
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言实现 基于poll的 多路复用 TCP echo 服务器模型

作者：知新_RL | 2024-04-04 23:54:37

赞

踩

C语言实现 基于poll的 多路复用 TCP echo 服务器模型

设计灵感:

1 单线程io多路复用服务端

2 使用poll实现

3 将server_sockfd client_sockfd 设为非阻塞,实现最大io效率

4 使用套接字选项SO_REUSEADDR 用于测试环境调试

5 将server_sockfd 和每一个有效的client_sockfd 都设为poll的监控事件

6 有客户端关闭连接时,自动从数组中删除,并调整相应的count值

功能:

可实现多客户端同时连接,echo收发无感

注意事项:

1 运行环境 unix-like gnu_c 

2 开启服务端后 可无限开启客户端

3 赠送对比用双循环阻塞服务端

4 赠送测试用客户端

poll多路复用服务端:

  1. #define _GNU_SOURCE
  2. #include <stdio.h>
  3. #include <sys/socket.h>
  4. #include <sys/un.h>
  5. #include <fcntl.h>
  6. #include <arpa/inet.h>
  7. #include <netinet/in.h>
  8. #include <sys/poll.h>
  9. #include <stdlib.h>
  10. #include <string.h>
  11. #include <unistd.h>
  12.  
  13. #define SERVER_IP "192.168.142.132"
  14. #define SERVER_PORT 50013
  15. // 设置非阻塞用函数
  16. void set_non_blocking(int sockfd)
  17. {
  18.     // 获取默认flags
  19.     int flags = fcntl(sockfd, F_GETFL, 0);
  20.     if (flags == -1)
  21.     {
  22.         perror("fcntl F_GETFL");
  23.     }
  24.     // 位运算 加上O_NONBLOCK
  25.     flags |= O_NONBLOCK;
  26.     // 设置 flags
  27.     if (fcntl(sockfd, F_SETFL, flags) == -1)
  28.     {
  29.         perror("fcntl F_SETFL");
  30.     }
  31. }
  32. int main()
  33. {
  34.     int server_sockfd, client_sockfd;
  35.     struct sockaddr_in server_sockaddr, client_sockaddr;
  36.     memset(&server_sockaddr, 0, sizeof(server_sockaddr));
  37.     memset(&client_sockaddr, 0, sizeof(client_sockaddr));
  38.     socklen_t client_sockaddr_len = sizeof(client_sockaddr);
  39.     socklen_t server_sockaddr_len = sizeof(server_sockaddr);
  40.     ssize_t send_bytes, recv_bytes;
  41.     char send_buf[1024] = "How can I he53453oday ?";
  42.     char recv_buf[1024] = {0};
  43.     // 循环用i,j,计数用count:pollfds[count]中每增加一个元素 count++
  44.     int i = 0, j = 0, count = 0;
  45.     // 系统允许的单进程 最大fd数量 1024576
  46.     long max_fds = sysconf(_SC_OPEN_MAX);
  47.     // 创建一个最大fd数量的数组,并将所有元素的所有字段设为0
  48.     struct pollfd *pollfds = calloc(max_fds, sizeof(struct pollfd));
  49.     if (pollfds == NULL)
  50.     {
  51.         perror("calloc");
  52.     }
  53.     // 将每个元素的fd设为-1,表示无效
  54.     for (i = 0; i < max_fds; i++)
  55.     {
  56.         pollfds[i].fd = -1;
  57.     }
  58.     // 又名 listen socket 用于监听请求,ipv4 tcp
  59.     server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
  60.     if (server_sockfd == -1)
  61.     {
  62.         perror("socket");
  63.     }
  64.     // 为什么要将server_sockfd设为非阻塞?
  65.     // server_sockfd相关的accept被poll监视,只有读就绪(有连接到来时)才回调用accept
  66.     // 这意味着accept通常不会阻塞,但是在极端情况下,客户端连接有迅速关闭,则accept有可能阻塞
  67.     set_non_blocking(server_sockfd);
  68.     // SO_REUSEADDR 地址端口复用,任意时刻只有一个socket能监听,主要用于程序重启
  69.     // SO_REUSEPORT 地址端口复用,同时监听,自动负载均衡
  70.     int optval = 1;
  71.     if (setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) == -1)
  72.     {
  73.         perror("setsockopt");
  74.     }
  75.     // 设置协议
  76.     server_sockaddr.sin_family = AF_INET;
  77.     // 设置转换端口
  78.     server_sockaddr.sin_port = htons(SERVER_PORT);
  79.     // 设置转换ip地址
  80.     if (inet_pton(AF_INET, SERVER_IP, &server_sockaddr.sin_addr.s_addr) == -1)
  81.     {
  82.         perror("inet_pton");
  83.     }
  84.     // 绑定
  85.     if (bind(server_sockfd, (struct sockaddr *)&server_sockaddr, server_sockaddr_len) == -1)
  86.     {
  87.         perror("bind");
  88.     }
  89.     // 监听,调整了最大等待数量为1024
  90.     if (listen(server_sockfd, 1024) == -1)
  91.     {
  92.         perror("listen");
  93.     }
  94.     // 将server_sockfd加入POLLIN监听事件
  95.     pollfds[0].fd = server_sockfd;
  96.     pollfds[0].events = POLLIN;
  97.     // count现在是0,++后变成1,遍历i<count,也就是判断pollfds[0]
  98.     // 但是pollfds[0]读就绪后,主要执行逻辑是accept,因此单独判断
  99.     count++;
  100.     printf("server start...\n");
  101.     while (1)
  102.     {
  103.         // 如果没有事件真实发生,程序将阻塞在此,而不是一味地循环
  104.         int r = poll(pollfds, count, -1);
  105.         // 至少有一个revent被设置
  106.         if (r > 0)
  107.         {
  108.             // 如果有连接请求
  109.             if (pollfds[0].revents & POLLIN)
  110.             {
  111.                 // 就连接
  112.                 client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_sockaddr, &client_sockaddr_len);
  113.                 if (client_sockfd == -1)
  114.                 {
  115.                     perror("accept");
  116.                 }
  117.                 // 将返回的client_sockfd设为非阻塞
  118.                 set_non_blocking(client_sockfd);
  119.                 // 如果代码首次到这,count就是1,pollfds[1]被填充,符合逻辑
  120.                 pollfds[count].fd = client_sockfd;
  121.                 // 同时监控读写
  122.                 pollfds[count].events = POLLIN | POLLOUT;
  123.                 // 向后挪一位
  124.                 count++;
  125.             }
  126.             // 首次加入监控事件的accept返回的client_sockfd不会在本次循环中被poll监控,需要等到下次循环
  127.             for (i = 1; i < count; i++)
  128.             {
  129.                 // 从索引1开始(索引0用于accept已单独处理),如果被监控的fd读就绪
  130.                 if (pollfds[i].revents & POLLIN)
  131.                 {
  132.                     // 读
  133.                     recv_bytes = recv(pollfds[i].fd, recv_buf, sizeof(recv_buf), 0);
  134.                     if (recv_bytes == -1)
  135.                     {
  136.                         perror("recv");
  137.                     }
  138.                     // 如果客户端关闭了连接
  139.                     if (recv_bytes == 0)
  140.                     {
  141.                         printf("close by peer\n");
  142.                         // 服务器也关闭连接
  143.                         close(pollfds[i].fd);
  144.                         // 1 将后面的fd往前挪
  145.                         for (j = i; j < count - 1; j++)
  146.                         {
  147.                             pollfds[j] = pollfds[j + 1];
  148.                         }
  149.                         // 2 最后一个fd是一个无效的副本 手动重置
  150.                         pollfds[count - 1].fd = -1;
  151.                         pollfds[count - 1].events = 0;
  152.                         pollfds[count - 1].revents = 0;
  153.                         // 3 count应该减1
  154.                         count--;
  155.                     }
  156.                     // 收到了数据
  157.                     if (recv_bytes > 0)
  158.                     {
  159.                         // 打印收到的数据
  160.                         printf("%s\n", recv_buf);
  161.                         // 同时,如果这个fd是写就绪的
  162.                         if (pollfds[i].revents & POLLOUT)
  163.                         {
  164.                             // 写
  165.                             send_bytes = send(pollfds[i].fd, send_buf, strlen(send_buf), 0);
  166.                             if (send_bytes == -1)
  167.                             {
  168.                                 perror("send");
  169.                             }
  170.                         }
  171.                     }
  172.                 }
  173.             }
  174.         }
  175.         if (r == -1)
  176.         {
  177.             perror("poll");
  178.         }
  179.     }
  180.     // 关闭server_sockfd,代码不可达
  181.     close(server_sockfd);
  182.     // 释放动态分配的内存,代码不可达
  183.     free(pollfds);
  184.  
  185.     return 0;
  186. }

对比用双循环阻塞服务端:

  1. #define _GNU_SOURCE
  2. #include <stdio.h>
  3. #include <sys/socket.h>
  4. #include <sys/un.h>
  5. #include <arpa/inet.h>
  6. #include <netinet/in.h>
  7. #include <string.h>
  8. #include <unistd.h>
  9.  
  10. #define SERVER_IP "192.168.142.132"
  11. #define SERVER_PORT 50013
  12.  
  13. int main()
  14. {
  15.     int server_sockfd, client_sockfd;
  16.     struct sockaddr_in server_sockaddr, client_sockaddr;
  17.     memset(&server_sockaddr, 0, sizeof(server_sockaddr));
  18.     memset(&client_sockaddr, 0, sizeof(client_sockaddr));
  19.     socklen_t client_sockaddr_len = sizeof(client_sockaddr);
  20.     ssize_t send_bytes, recv_bytes;
  21.     char send_buf[1024] = "How can I help you today ?";
  22.     char recv_buf[1024] = {0};
  23.  
  24.     server_sockfd = socket(AF_INET, SOCK_STREAM, 0);
  25.     if (server_sockfd == -1)
  26.     {
  27.         perror("socket");
  28.     }
  29.  
  30.     int optval = 1;
  31.     setsockopt(server_sockfd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval));
  32.  
  33.     server_sockaddr.sin_family = AF_INET;
  34.     inet_pton(AF_INET, SERVER_IP, &server_sockaddr.sin_addr.s_addr);
  35.     server_sockaddr.sin_port = htons(SERVER_PORT);
  36.     if (bind(server_sockfd, (struct sockaddr *)&server_sockaddr, sizeof(server_sockaddr)) == -1)
  37.     {
  38.         perror("bind");
  39.     }
  40.  
  41.     if (listen(server_sockfd, 16) == -1)
  42.     {
  43.         perror("listen");
  44.     }
  45.  
  46.     printf("server start...\n");
  47.  
  48.     while (1)
  49.     {
  50.         client_sockfd = accept(server_sockfd, (struct sockaddr *)&client_sockaddr, &client_sockaddr_len);
  51.         if (client_sockfd == -1)
  52.         {
  53.             perror("accept");
  54.         }
  55.         while (1)
  56.         {
  57.  
  58.             recv_bytes = recv(client_sockfd, recv_buf, sizeof(recv_buf), 0);
  59.             if (recv_bytes == -1)
  60.             {
  61.                 perror("recv");
  62.             }
  63.             else if (recv_bytes == 0)
  64.             {
  65.                 printf("closed by peer\n");
  66.                 break;
  67.             }
  68.             else
  69.             {
  70.                 printf("%s\n", recv_buf);
  71.             }
  72.             send_bytes = send(client_sockfd, send_buf, strlen(send_buf), 0);
  73.             if (send_bytes == -1)
  74.             {
  75.                 perror("send");
  76.             }
  77.         }
  78.     }
  79.     close(server_sockfd);
  80.     return 0;
  81. }

测试用客户端:

  1. #define _GNU_SOURCE
  2. #include <stdio.h>
  3. #include <sys/socket.h>
  4. #include <sys/un.h>
  5. #include <arpa/inet.h>
  6. #include <netinet/in.h>
  7. #include <string.h>
  8. #include <unistd.h>
  9. #include <stdlib.h>
  10. #include <time.h>
  11. #include <fcntl.h>
  12. #define SERVER_IP "192.168.142.132"
  13. #define SERVER_PORT 50013
  14. int set_non_blocking(int sockfd)
  15. {
  16.     int flags = fcntl(sockfd, F_GETFL, 0);
  17.     if (flags == -1)
  18.     {
  19.         perror("fcntl(F_GETFL)");
  20.     }
  21.  
  22.     flags |= O_NONBLOCK;
  23.  
  24.     if (fcntl(sockfd, F_SETFL, flags) == -1)
  25.     {
  26.         perror("fcntl(F_SETFL)");
  27.     }
  28.  
  29.     return 0;
  30. }
  31. int main()
  32. {
  33.     int client_sockfd;
  34.     struct sockaddr_in server_sockaddr, client_sockaddr;
  35.     memset(&server_sockaddr, 0, sizeof(server_sockaddr));
  36.     memset(&client_sockaddr, 0, sizeof(client_sockaddr));
  37.     socklen_t client_sockaddr_len = sizeof(client_sockaddr);
  38.     ssize_t send_bytes, recv_bytes;
  39.     char send_buf[1024] = {0};
  40.     char recv_buf[1024] = {0};
  41.  
  42.     client_sockfd = socket(AF_INET, SOCK_STREAM, 0);
  43.     if (client_sockfd == -1)
  44.     {
  45.         perror("socket");
  46.     }
  47.  
  48.     //set_non_blocking(client_sockfd);
  49.  
  50.     inet_pton(AF_INET, SERVER_IP, &server_sockaddr.sin_addr.s_addr);
  51.     server_sockaddr.sin_port = htons(SERVER_PORT);
  52.     server_sockaddr.sin_family = AF_INET;
  53.     if (connect(client_sockfd, (struct sockaddr *)&server_sockaddr, sizeof(server_sockaddr)) == -1)
  54.     {
  55.         perror("connect");
  56.     }
  57.  
  58.     getsockname(client_sockfd, (struct sockaddr *)&client_sockaddr, &client_sockaddr_len);
  59.     snprintf(send_buf, sizeof(send_buf), "%u:he###llo s???ver !!!",
  60.              ntohs(client_sockaddr.sin_port));
  61.     while (1)
  62.     {
  63.         send_bytes = send(client_sockfd, send_buf, strlen(send_buf), 0);
  64.         if (send_bytes == -1)
  65.         {
  66.             perror("send");
  67.         }
  68.         recv_bytes = recv(client_sockfd, recv_buf, sizeof(recv_buf), 0);
  69.         if (recv_bytes == -1)
  70.         {
  71.             perror("recv");
  72.         }
  73.         printf("%s\n", recv_buf);
  74.         sleep(2);
  75.     }
  76.     close(client_sockfd);
  77.     return 0;
  78. }

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/知新_RL/article/detail/362008?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号