• linux并发服务器 —— IO多路复用（八）

    半关闭、端口复用

    半关闭只能实现数据单方向的传输；当TCP 接中A向 B 发送 FIN 请求关闭，另一端 B 回应ACK 之后 (A 端进入 FIN_WAIT_2 状态)，并没有立即发送 FIN 给 A，A 方处于半连接状态 (半开关)，此时 A 可以接收 B 发送的数据，但是 A 已经不能再向 B 发送数据

    close不会影响到其他进程，shutdown会影响到其他进程；

    网络信息相关的命令

    netstat

            -a 所有的Socket

            -p 正在所用socket的程序名称

            -n 直接使用IP地址，不通过域名服务器

    端口复用

    1. 防止服务器重启时之前绑定的端口还没释放

    2. 程序突然退出而系统没有释放端口

    IO多路复用简介

    I/O多路复用使程序可以同时监听多个文件描述符，提高程序性能；select/poll/epoll

    阻塞等待：不占用CPU宝贵时间；但同一时刻只能处理一个操作，效率低。

    非阻塞，忙轮询：提高了程序执行效率；但会占用更多的CPU资源。

    select/poll：委托内核进行检测，但仍需要进行遍历

    epoll：同样委托内核，但无需进行遍历

    select

    主旨思想：

    1. 构造关于文件描述符的列表，将要监听的文件描述符添加到表中

    2. 调用系统函数，监听该列表中的文件描述符，知道描述符中的一个/多个进行了I/O操作，函数才返回（该函数是阻塞的，且该函数对于文件描述符的检测是由内核完成的）

    3. 返回时，告诉进程有多少描述符要进行I/O操作

    返回值： 失败 - -1，成功 - 检测到的描述符个数

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include  
    8.  
    9. using namespace std;
    10.  
    11. int main(){
    12.  
    13.     // 创建socket
    14.     int lfd = socket(PF_INET , SOCK_STREAM , 0);
    15.     struct sockaddr_in saddr;
    16.     saddr.sin_port = htons(9999);
    17.     saddr.sin_family = AF_INET;
    18.     saddr.sin_addr.s_addr = INADDR_ANY;
    19.     // 绑定
    20.     bind(lfd , (struct sockaddr*)&saddr , sizeof(saddr));
    21.     // 监听
    22.     listen(lfd , 8);
    23.  
    24.     fd_set rdset , tmp;
    25.     FD_ZERO(&rdset);
    26.     FD_SET(lfd , &rdset);
    27.     int maxfd = lfd+1;
    28.     while(1){
    29.         tmp = rdset;
    30.         // 调用select 系统检测
    31.         int ret = select(maxfd+1 , &tmp , NULL , NULL , NULL);
    32.         if(ret == -1){
    33.             perror("select");
    34.             exit(-1);
    35.         }
    36.         else if(ret == 0){
    37.             continue;
    38.         }
    39.         else{
    40.             // 检测到了文件描述符的数据发生了改变
    41.             if(FD_ISSET(lfd , &tmp)){
    42.                 // 有客户端连接进来
    43.                 struct sockaddr_in caddr;
    44.                 socklen_t len = sizeof(caddr);
    45.                 int cfd = accept(lfd , (struct sockaddr*)&caddr , &len);
    46.                 // 添加进去
    47.                 FD_SET(cfd , &rdset);
    48.  
    49.                 maxfd = maxfd>cfd?maxfd:cfd+1;
    50.             }
    51.             for(int i = lfd+1 ; i <= maxfd ; i++){
    52.                 if(FD_ISSET(i , &tmp)){
    53.                     // 说明客户端发来了数据
    54.                     char buf[1024];
    55.                     int len = read(i , buf , sizeof(buf));
    56.                     if(len == -1){
    57.                         perror("read");
    58.                         exit(-1);
    59.                     }
    60.                     else if(len == 0){
    61.                         cout<<"client close..."<
    62.                         close(i);
    63.                         FD_CLR(i,&rdset);
    64.                     }
    65.                     else{
    66.                         cout<<"发来了数据："<
    67.                         write(i , buf , strlen(buf)+1);
    68.                     }
    69.                 }
    70.             }
    71.         }
    72.     }
    73.     close(lfd);
    74.     return 0;
    75. }

    poll

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include  
    8.  
    9. using namespace std;
    10.  
    11. int main(){
    12.  
    13.     // 创建socket
    14.     int lfd = socket(PF_INET , SOCK_STREAM , 0);
    15.     struct sockaddr_in saddr;
    16.     saddr.sin_port = htons(9999);
    17.     saddr.sin_family = AF_INET;
    18.     saddr.sin_addr.s_addr = INADDR_ANY;
    19.     // 绑定
    20.     bind(lfd , (struct sockaddr*)&saddr , sizeof(saddr));
    21.     // 监听
    22.     listen(lfd , 8);
    23.  
    24.     // 初始化检测文件描述符数组
    25.     struct pollfd fds[1024];
    26.     for(int i = 0 ; i<1024 ; i++){
    27.         fds[i].fd = -1;
    28.         fds[i].events = POLLIN;
    29.     }
    30.     fds[0].fd = lfd;
    31.  
    32.     int nfds = 0;
    33.  
    34.     while(1){
    35.         // poll 系统检测
    36.         int ret = poll(fds , nfds+1 , -1);
    37.         if(ret == -1){
    38.             perror("poll");
    39.             exit(-1);
    40.         }
    41.         else if(ret == 0){
    42.             continue;
    43.         }
    44.         else{
    45.             // 检测到了文件描述符的数据发生了改变
    46.             if(fds[0].revents & POLLIN){
    47.                 // 有客户端连接进来
    48.                 struct sockaddr_in caddr;
    49.                 socklen_t len = sizeof(caddr);
    50.                 int cfd = accept(lfd , (struct sockaddr*)&caddr , &len);
    51.                 // 添加进去
    52.                 for(int i = 1 ; i < 1024 ; i++){
    53.                     if(fds[i].fd == -1){
    54.                         fds[i].fd = cfd;
    55.                         fds[i].events = POLLIN;
    56.                         break;
    57.                     }
    58.                 }
    59.  
    60.                 nfds = nfds>cfd?nfds:cfd;
    61.             }
    62.             for(int i = 1 ; i <= nfds ; i++){
    63.                 if(fds[i].revents & POLLIN){
    64.                     // 说明客户端发来了数据
    65.                     char buf[1024];
    66.                     int len = read(fds[i].fd , buf , sizeof(buf));
    67.                     if(len == -1){
    68.                         perror("read");
    69.                         exit(-1);
    70.                     }
    71.                     else if(len == 0){
    72.                         cout<<"client close..."<
    73.                         close(fds[i].fd);
    74.                         fds[i].fd = -1;
    75.                     }
    76.                     else{
    77.                         cout<<"发来了数据："<
    78.                         write(fds[i].fd , buf , strlen(buf)+1);
    79.                     }
    80.                 }
    81.             }
    82.         }
    83.     }
    84.     close(lfd);
    85.     return 0;
    86. }

    epoll

    内核，红黑树记录要检测的文件描述符，避免了用户态到内核态的数据拷贝开销；

    内核，双链表存放数据改变的文件描述符

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include  
    8.  
    9. using namespace std;
    10.  
    11. int main(){
    12.     // 创建socket
    13.     int lfd = socket(PF_INET , SOCK_STREAM , 0);
    14.     struct sockaddr_in saddr;
    15.     saddr.sin_port = htons(9999);
    16.     saddr.sin_family = AF_INET;
    17.     saddr.sin_addr.s_addr = INADDR_ANY;
    18.     // 绑定
    19.     bind(lfd , (struct sockaddr*)&saddr , sizeof(saddr));
    20.     // 监听
    21.     listen(lfd , 8);
    22.     // 创建epoll实例
    23.     int epfd = epoll_create(100);
    24.     // 添加监听文件描述符
    25.     struct epoll_event epev;
    26.     epev.events = EPOLLIN;
    27.     epev.data.fd = lfd;
    28.     epoll_ctl(epfd , EPOLL_CTL_ADD , lfd , &epev);
    29.  
    30.     struct epoll_event epevs[1024];
    31.     while(1){
    32.         int ret = epoll_wait(epfd , epevs , 1024 , -1);
    33.         if(ret == -1){
    34.             perror("epoll");
    35.             exit(-1);
    36.         }
    37.         cout<"个发生了改变"<
    38.         for(int i = 0 ; i
    39.             int curfd = epevs[i].data.fd;
    40.             if(curfd == lfd){
    41.                 // 监听的文件描述符有客户端连接
    42.                 struct sockaddr_in caddr;
    43.                 socklen_t len = sizeof(caddr);
    44.                 int cfd = accept(lfd , (struct sockaddr*)&caddr , &len);
    45.                 epev.events = EPOLLIN;
    46.                 epev.data.fd = cfd;
    47.                 epoll_ctl(epfd , EPOLL_CTL_ADD , cfd , &epev);
    48.             }
    49.             else{
    50.                 // 有数据到达
    51.                 char buf[1024];
    52.                 int len = read(curfd , buf , sizeof(buf));
    53.                 if(len == -1){
    54.                     perror("read");
    55.                     exit(-1);
    56.                 }
    57.                 else if(len == 0){
    58.                     cout<<"client close..."<
    59.                     epoll_ctl(epfd , EPOLL_CTL_DEL , curfd , NULL);
    60.                     close(curfd);
    61.                 }
    62.                 else{
    63.                     cout<<"发来了数据："<
    64.                     write(curfd , buf , strlen(buf)+1);
    65.                 }
    66.             }
    67.         }
    68.     }
    69.     close(lfd);
    70.     close(epfd);
    71.  
    72.     return 0;
    73. }

    epoll的两种工作模式

    LT模式 - 水平触发

    默认的工作模式，支持block/no-block；，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的 fd 进行IO操作。如果你不作任何操作，内核还是会继续通知你

    1. #include 
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include  
    8.  
    9. using namespace std;
    10.  
    11. int main(){
    12.     // 创建socket
    13.     int lfd = socket(PF_INET , SOCK_STREAM , 0);
    14.     struct sockaddr_in saddr;
    15.     saddr.sin_port = htons(9999);
    16.     saddr.sin_family = AF_INET;
    17.     saddr.sin_addr.s_addr = INADDR_ANY;
    18.     // 绑定
    19.     bind(lfd , (struct sockaddr*)&saddr , sizeof(saddr));
    20.     // 监听
    21.     listen(lfd , 8);
    22.     // 创建epoll实例
    23.     int epfd = epoll_create(100);
    24.     // 添加监听文件描述符
    25.     struct epoll_event epev;
    26.     epev.events = EPOLLIN;
    27.     epev.data.fd = lfd;
    28.     epoll_ctl(epfd , EPOLL_CTL_ADD , lfd , &epev);
    29.  
    30.     struct epoll_event epevs[1024];
    31.     while(1){
    32.         int ret = epoll_wait(epfd , epevs , 1024 , -1);
    33.         if(ret == -1){
    34.             perror("epoll");
    35.             exit(-1);
    36.         }
    37.         cout<"个发生了改变"<
    38.         for(int i = 0 ; i
    39.             int curfd = epevs[i].data.fd;
    40.             if(curfd == lfd){
    41.                 // 监听的文件描述符有客户端连接
    42.                 struct sockaddr_in caddr;
    43.                 socklen_t len = sizeof(caddr);
    44.                 int cfd = accept(lfd , (struct sockaddr*)&caddr , &len);
    45.                 epev.events = EPOLLIN;
    46.                 epev.data.fd = cfd;
    47.                 epoll_ctl(epfd , EPOLL_CTL_ADD , cfd , &epev);
    48.             }
    49.             else{
    50.                 // 有数据到达
    51.                 char buf[5];
    52.                 int len = read(curfd , buf , sizeof(buf));
    53.                 if(len == -1){
    54.                     perror("read");
    55.                     exit(-1);
    56.                 }
    57.                 else if(len == 0){
    58.                     cout<<"client close..."<
    59.                     epoll_ctl(epfd , EPOLL_CTL_DEL , curfd , NULL);
    60.                     close(curfd);
    61.                 }
    62.                 else{
    63.                     cout<<"发来了数据："<
    64.                     write(curfd , buf , strlen(buf)+1);
    65.                 }
    66.             }
    67.         }
    68.     }
    69.     close(lfd);
    70.     close(epfd);
    71.  
    72.     return 0;
    73. }
    ET模式 - 边沿触发

    告诉工作方式，只支持no-block，在这种模式下，当描述符从未就绪变为就绪时，内核通过epol告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了。但是请注意如果一直不对这个 fd 作IO操作，内核不会发送更多的通知 (only once) 。但是缓冲区中的数据不会丢失

    ET模式效率比LT模式高，ET模式下必须使用非阻塞套接口，避免由于一个描述符的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死；

    要设置边沿触发

    1. 需要在epoll_event中设置EPOLLET

    2. 

    UDP通信实现 - 无需多进程/多线程的并发实现

    1. // server
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. using namespace std;
    9.  
    10. int main(){
    11.     // 创建socket
    12.     int fd = socket(PF_INET , SOCK_DGRAM , 0);
    13.     if(fd == -1){
    14.         perror("socket");
    15.         exit(-1);
    16.     }
    17.     // 绑定
    18.     struct sockaddr_in addr;
    19.     addr.sin_family = AF_INET;
    20.     addr.sin_port = htons(9999);
    21.     addr.sin_addr.s_addr = INADDR_ANY;
    22.     
    23.     int ret = bind(fd ,(struct sockaddr*) &addr , sizeof(addr));
    24.     if(ret == -1){
    25.         perror("bind");
    26.         exit(-1);
    27.     }
    28.  
    29.     // 通信
    30.     while(1){
    31.         // 接收数据
    32.         char buf[128];
    33.         char ip[16];
    34.         struct sockaddr_in caddr;
    35.         socklen_t len = sizeof(caddr);
    36.         int num = recvfrom(fd , buf , sizeof(buf) , 0 , (struct sockaddr*)&caddr , &len);
    37.         string s1 = "IP: ";
    38.         s1 += inet_ntop(AF_INET , &caddr.sin_addr.s_addr , ip , sizeof(ip));
    39.         string s2 = "Port: ";
    40.         s2 += ntohs(caddr.sin_port);
    41.         cout<" "<
    42.         cout<<"rcv data: "<
    43.  
    44.         sendto(fd , buf , strlen(buf)+1 , 0 , (struct sockaddr*)&caddr , len);
    45.     }
    46.  
    47.     close(fd);
    48.     return 0;
    49. }
    1. // client
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. using namespace std;
    9.  
    10. int main(){
    11.     // 创建socket
    12.     int fd = socket(PF_INET , SOCK_DGRAM , 0);
    13.     if(fd == -1){
    14.         perror("socket");
    15.         exit(-1);
    16.     }
    17.  
    18.     struct sockaddr_in addr;
    19.     addr.sin_family = AF_INET;
    20.     addr.sin_port = htons(9999);
    21.     inet_pton(AF_INET , "127.0.0.1" , &addr.sin_addr.s_addr);
    22.  
    23.     // 通信
    24.     int num = 0;
    25.     socklen_t len = sizeof(addr);
    26.     while(1){
    27.         char buf[128];
    28.         sprintf(buf , "hello 647 %d" , num++);
    29.         sendto(fd , buf , strlen(buf)+1 , 0 , (struct sockaddr*)&addr , len);
    30.         // 接收数据
    31.         int num = recvfrom(fd , buf , sizeof(buf) , 0 , NULL , NULL);
    32.         cout<<"rcv data: "<
    33.  
    34.         sleep(1);
    35.  
    36.     }
    37.  
    38.     close(fd);
    39.     return 0;
    40. }

    广播和组播 - 只能使用UDP

    广播 - 向子网中多台计算机发送消息，每个广播消息都包含一个特殊的IP地址，这个IP中子网内主机标志部分的二进制全部为1；

    1. 只能在局域网中使用

    2. 客户端需要绑定服务器广播使用的端口，才能接收到广播消息

    组播 （多播） - 标识一组IP接口，是在单播和广播之间的一种折中方案，多播数据包只由对其感兴趣的接口接收；

    1. 组播可以用于局域网和广域网

    2. 客户端需要加入多播组才能接收到

    本地套接字通信

    作用：用于进程间的通信；实现流程和网络套接字类似，一般采用TCP的通信流程

    1. 服务器端
    2.  
    3. 1. 创建监听的套接字
    4.  
    5.       int lfd = socket（AF_UNIX/AF_LOCAL ， SOCK_STREAM , 0）;
    6.  
    7. 2. 监听套接字绑定本地的套接字文件
    8.  
    9.         struct sockaddr_un addr;
    10.  
    11.         bind(lfd, addr, len); // 绑定成功后sun_path中的套接字文件会自动生成
    12.  
    13. 3. 监听
    14.  
    15. 4. 等待并接受客户端请求
    16.  
    17. 5. 通信
    18.  
    19. 6. 关闭连接
    1. 客户端
    2.  
    3. 1. 创建通信的套接字
    4.  
    5. 2. 绑定本地IP端口
    6.  
    7. 3. 连接服务器
    8.  
    9. 4. 通信
    10.  
    11. 5. 关闭连接
    1. // 服务端
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. using namespace std;
    10.  
    11. int main(){
    12.     unlink("server.sock");
    13.     // 创建监听套接字
    14.     int lfd = socket(AF_LOCAL , SOCK_STREAM , 0);
    15.     if(lfd == -1){
    16.         perror("socket");
    17.         exit(-1);
    18.     }
    19.     // 绑定本地套接字文件
    20.     struct sockaddr_un addr;
    21.     addr.sun_family = AF_LOCAL;
    22.     strcpy(addr.sun_path , "server.sock");
    23.     int ret = bind(lfd , (struct sockaddr*)&addr , sizeof(addr));
    24.     if(ret == -1){
    25.         perror("bind");
    26.         exit(-1);
    27.     }
    28.     // 监听
    29.     ret = listen(lfd , 100);
    30.     if(ret == -1){
    31.         perror("listen");
    32.         exit(-1);
    33.     }
    34.     // 等待客户端连接
    35.     struct sockaddr_un caddr;
    36.     socklen_t len = sizeof(caddr);
    37.     int cfd = accept(lfd , (struct sockaddr*)&caddr , &len);
    38.     if(cfd == -1){
    39.         perror("accept");
    40.         exit(-1);
    41.     }
    42.  
    43.     cout<<"客户端文件："<
    44.     // 通信
    45.     while(1){
    46.         char buf[128];
    47.         int len = recv(cfd , buf , sizeof(buf) , 0);
    48.         if(len ==  -1){
    49.             perror("recv");
    50.             exit(-1);
    51.         }
    52.         else if(len == 0){
    53.             cout<<"client close..."<
    54.             break;
    55.         }
    56.         else{
    57.             cout<<"recv data: "<
    58.             send(cfd , buf , len , 0);
    59.         }
    60.     }
    61.     close(cfd);
    62.     close(lfd);
    63.     return 0;
    64. }
    1. // 客户端
    2. #include 
    3. #include 
    4. #include 
    5. #include 
    6. #include 
    7. #include 
    8. #include 
    9. using namespace std;
    10.  
    11. int main(){
    12.     unlink("client.sock");
    13.     // 创建监听套接字
    14.     int cfd = socket(AF_LOCAL , SOCK_STREAM , 0);
    15.     if(cfd == -1){
    16.         perror("socket");
    17.         exit(-1);
    18.     }
    19.     // 绑定本地套接字文件
    20.     struct sockaddr_un addr;
    21.     addr.sun_family = AF_LOCAL;
    22.     strcpy(addr.sun_path , "client.sock");
    23.     int ret = bind(cfd , (struct sockaddr*)&addr , sizeof(addr));
    24.     if(ret == -1){
    25.         perror("bind");
    26.         exit(-1);
    27.     }
    28.     // 连接服务器
    29.     struct sockaddr_un saddr;
    30.     saddr.sun_family = AF_LOCAL;
    31.     strcpy(saddr.sun_path , "server.sock");
    32.     ret = connect(cfd , (struct sockaddr*)&saddr , sizeof(saddr));
    33.     if(ret == -1){
    34.         perror("connect");
    35.         exit(-1);
    36.     }
    37.  
    38.     // 通信
    39.     int num = 0;
    40.     while(1){
    41.         char buf[128];
    42.         sprintf(buf , "hello 647 %d\n" , num++);
    43.         send(cfd , buf , strlen(buf)+1 , 0);
    44.  
    45.         int len = recv(cfd , buf , sizeof(buf) , 0);
    46.         if(len ==  -1){
    47.             perror("recv");
    48.             exit(-1);
    49.         }
    50.         else if(len == 0){
    51.             cout<<"Server close..."<
    52.             break;
    53.         }
    54.         else{
    55.             cout<<"recv data: "<
    56.         }
    57.         sleep(1);
    58.     }
    59.     close(cfd);
    60.     return 0;
    61. }

  • 相关阅读:
    系分 - 操作系统 - 嵌入式
    【PID优化】基于樽海鞘算法PID控制器优化设计含Matlab源码
    Maven引入Aspose依赖
    六级高频词汇——Group02
    模拟一个火车站售票小例子
    Spark RDD算子
    mysql主从和mycat读写分离的安装及验证
    1.Javascript-JavaScript事件
    Jetson Nano TensorRT C++加速 YOLOV5，集成进qt项目中
    计算机网络：随机访问介质访问控制之令牌传递协议
  • 原文地址：https://blog.csdn.net/rygy_/article/details/132677809