• epoll实现 IO复用

    1、epoll实现 IO复用

    epoll的提出--》它所支持的文件描述符上限是系统可以最大打开的文件的数目；eg：1GB机器上，这个上限10万个左右。 每个fd上面有callback(回调函数)函数，只有活跃的fd才有主动调用callback，不需要轮询。 注意： Epoll处理高并发，百万级，不关心底层怎样实现，只需要会调用就可以。

    函数接口

    1. #include <sys/epoll.h>
    2. int epoll_create(int size); 
    3. 功能：创建红黑树根节点
    4.  参数：size：不作为实际意义值 >0 即可
    5. 返回值：成功时返回epoll文件描述符，失败时返回-1。
    6.  
    7. int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
    8. 功能：控制epoll属性
    9.     epfd:epoll_create函数的返回句柄。7、】=
    10.     op:表示动作类型。有三个宏 来表示：
    11.             EPOLL_CTL_ADD：注册新的fd到epfd中
    12.             EPOLL_CTL_MOD：修改已注册fd的监听事件
    13.             EPOLL_CTL_DEL：从epfd中删除一个fd
    14.     Fd:需要监听的fd。
    15.             event:告诉内核需要监听什么事件
    16.             EPOLLIN:表示对应文件描述符可读
    17.             EPOLLOUT:可写
    18.             EPOLLPRI：有紧急数据可读；
    19.             EPOLLERR：错误；
    20.             EPOLLHUP：被挂断；
    21.             EPOLLET：触发方式，边缘触发；(默认使用边缘触发)
    22.              ET模式：表示状态的变化；
    23. 返回值：成功时返回0，失败时返回-1
    24.  
    25. typedef union epoll_data 
    26. {
    27.       void* ptr;(无效)
    28.       int fd;
    29.       uint32_t u32;
    30.       uint64_t u64;
    31. } epoll_data_t;
    32. struct epoll_event 
    33. {
    34.     uint32_t events； / * Epoll事件* /
    35.     epoll_data_t data； / *用户数据变量* /
    36. };
    37. //等待事件到来
    38. int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
    39. 功能：等待事件的产生，类似于select的用法
    40.      epfd:句柄；
    41.      events：用来保存从内核得到事件的集合；
    42.      maxevents:表示每次能处理事件最大个数；
    43.      timeout：超时时间，毫秒，0立即返回，-1阻塞
    44. 成功时返回发生事件的文件描述个数，失败时返回-1

    select,poll都属于 同步IO机制(轮询)

    epoll属于异步IO机制(不轮询): 

    epoll的提出--》它所支持的文件描述符上限是系统可以最大打开的文件的数目；

                           eg：1GB机器上，这个上限10万个左右。

    每个fd上面有callback(回调函数)函数，只有产生事件的fd才有主动调用callback，不需要轮询。

    注意：

      Epoll处理高并发，百万级

    1. 红黑树： 是特殊的二叉树(每个节点带有属性)，Epoll怎样能监听很多个呢？首先创建树的根节点，每个节点都是一个fd以结构体的形式存储（节点里面包含了一些属性，callback函数）
    2. 就绪链表： 当某一个文件描述符产生事件后，会自动调用callback函数，通过回调callback函数来找到链表对应的事件（读时间还是写事件)。

    2、epoll特点

    1. 监听的最大的文件描述符没有个数限制（取决与你自己的系统 1GB - 10万个左右）
    2. 异步I/O，epoll当有事件产生被唤醒之后，文件描述符主动调用callback(回调函数)函数直接拿到唤醒的文件描述符，不需要轮询，效率高

    3.epoll不需要重新构造文件描述符表，只需要从用户空间向内核空间拷贝一次数据即可.

    3、epoll的流程: 

    Epoll的使用:

    1.创建红黑树 和 就绪链表         

    2.添加文件描述符和事件信息到树上

    3.阻塞等待事件的产生，一旦产生事件，则进行处理

    4.根据链中准备处理的文件描述符 进行处理

    epoll 要使用一组函数:  epoll_create 创建红黑树 和 就序列表

                                          epoll_ctl   添加文件描述符和事件到树上 / 从树上删除

                                         epoll_wait  等待事件产生

    1）epoll_create 创建红黑树以及链表
    1. 头文件:#include 
    2. 声明:int epoll_create(int size); 
    3. 功能：创建红黑树根节点(创建epoll实例) , 同时也会创建就绪链表
    4. 返回值：成功时返回一个实例(二叉树句柄)，失败时返回-1。
    2）epoll_ctl 控制epoll属性

    1. 声明: int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
    2.  
    3. 功能：控制epoll属性,比如给红黑树添加节点
    4.  
    5. 参数: 1. epfd:   epoll_create函数的返回句柄。//一个标识符
    6.      2. op:表示动作类型,有三个宏:			        
    7.                 EPOLL_CTL_ADD：注册新的fd到epfd中
    8. 			      EPOLL_CTL_MOD：修改已注册fd的监听事件
    9. 			      EPOLL_CTL_DEL：从epfd中删除一个fd
    10.      3. 要操作的文件描述符
    11.      4. 结构体信息: 
    12.  typedef union epoll_data 
    13. {
    14.      int fd;      //要添加的文件描述符
    15.      uint32_t u32;  typedef unsigned int
    16.      uint64_t u64;   typedef unsigned long int
    17. } epoll_data_t;
    18.  
    19. struct epoll_event 
    20. {
    21.    uint32_t events； 事件
    22.    epoll_data_t data； //共用体(看上面)
    23. };
    24.  
    25. 	  关于events事件:
    26. 			 EPOLLIN:  表示对应文件描述符可读
    27. 		    EPOLLOUT: 可写
    28. 			 EPOLLPRI：有紧急数据可读；
    29. 		    EPOLLERR：错误；
    30. 		    EPOLLHUP：被挂断；
    31. 			 EPOLLET：触发方式，边缘触发；(默认使用边缘触发)
    32. 			 ET模式：表示状态的变化；
    33.            NULL: 删除一个文件描述符使用,无事件
    34.            
    35. 返回值：成功:0， 失败:-1
    36.
    3）epoll_wait等待事件产生
    1. 声明: int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
    2.  
    3. 功能：等待事件产生
    4.    内核会查找红黑树中有事件响应的文件描述符, 并将结构体放入就绪链表
    5.     就绪链表中的内容, 执行epoll_wait会同时复制到第二个参数events
    6.  
    7. 参数: 	epfd:句柄；
    8. 		events：用来保存从就绪链表中响应事件的集合；
    9. 		maxevents:  表示每次在链表中拿取响应事件的个数；
    10. 		timeout：超时时间，毫秒，0立即返回  ，-1阻塞	
    11.  
    12. 返回值: 成功: 实际从链表中拿出的数目     失败时返回-1
    13.

    练习epoll实现服务器端

    1. #include <stdio.h>
    2. #include <sys/types.h> /* See NOTES */
    3. #include <sys/socket.h>
    4. #include <netinet/in.h>
    5. #include <netinet/ip.h> /* superset of previous */
    6. #include <netinet/in.h>
    7. #include <arpa/inet.h>
    8. #include <unistd.h>
    9. #include <stdlib.h>
    10. #include <stdio.h>
    11. #include <unistd.h>
    12. #include <string.h>
    13. #include <sys/types.h>
    14. #include <sys/stat.h>
    15. #include <fcntl.h>
    16. #include <sys/epoll.h>
    17. int main(int argc, char const *argv[])
    18. {
    19.     if (argc < 2)
    20.     {
    21.         printf("plase input \n");
    22.         return -1;
    23.     }
    24.     //1.创建套接字,用于链接
    25.     int sockfd;
    26.     int acceptfd;
    27.     sockfd = socket(AF_INET, SOCK_STREAM, 0);
    28.     if (sockfd < 0)
    29.     {
    30.         perror("socket err");
    31.         return -1;
    32.     }
    33.     printf("sockfd:%d\n", sockfd);
    34.     //2.绑定 ip+port 填充结构体
    35.     struct sockaddr_in saddr;
    36.     saddr.sin_family = AF_INET;                   //协议族ipv4
    37.     saddr.sin_port = htons(atoi(argv[1]));        //端口号,htons将无符号短整数hostshort从主机字节顺序到网络字节顺序。
    38.     saddr.sin_addr.s_addr = inet_addr("0.0.0.0"); //ip地址,转化为16进制表示
    39.     socklen_t len = sizeof(saddr);                //结构体大小
    40.     //bind绑定ip和端口
    41.     if (bind(sockfd, (struct sockaddr *)&saddr, len) < 0)
    42.     {
    43.         perror("bind err");
    44.         return -1;
    45.     }
    46.     printf("bind success\n");
    47.     //3.启动监听,把主动套接子变为被动套接字
    48.     if (listen(sockfd, 1) < 0)
    49.     {
    50.         perror("listen err");
    51.         return -1;
    52.     }
    53.     printf("listen success\n");
    54.    
    55.     
    56.     //引入epoll
    57.     //创建结构体变量
    58.     struct epoll_event event;
    59.     struct epoll_event revents[32];//存放epoll_wait拿取的内容
    60.     //1.创建树
    61.     int epfd=epoll_create(1);
    62.     // if (epfd = epoll_creat(1) < 0)
    63.     // {
    64.     //     perror(" creat err");
    65.     //     return -1;
    66.     // }
    67.     //2.将关心的文件描述符添加到树上
    68.     //标准输入上树
    69.     event.events = EPOLLIN | EPOLLET;
    70.     event.data.fd = 0;
    71.     epoll_ctl(epfd, EPOLL_CTL_ADD, 0, &event);
    72.     //套接字上树
    73.     event.data.fd = sockfd;
    74.     epoll_ctl(epfd, EPOLL_CTL_ADD, sockfd, &event);
    75.  
    76.     char buf[64] = {0};//字符数组
    77.     //3.在链表中取事件
    78.  
    79.     while (1)
    80.     {
    81.         //3.阻塞 等待文件描述符产生事件
    82.         int ret = epoll_wait(epfd, revents, 10, -1);
    83.         if (ret < 0)
    84.         {
    85.             perror(" epoll_wait err");
    86.             return -1;
    87.         }
    88.         //4.根据文件描述符 进行处理
    89.         for (int i = 0; i < ret; i++)
    90.         {
    91.             if (revents[i].data.fd == 0)
    92.             {
    93.                 //5.执行操作
    94.                 fgets(buf, sizeof(buf), stdin);
    95.                 if (buf[strlen(buf)] == '\0') //去掉fgets补的'\n'
    96.                 {
    97.                     buf[strlen(buf) - 1] = '\0';
    98.                 }
    99.                     send(event.data.fd, buf, sizeof(buf), 0); //发送
    100.  
    101.             }
    102.             else if (revents[i].data.fd == sockfd)
    103.             {
    104.                 int acceptfd = accept(sockfd, (struct sockaddr *)&saddr, &len);
    105.                 if (acceptfd < 0)
    106.                 {
    107.                     perror("accept is err:");
    108.                     return -1;
    109.                 }
    110.                 printf("fd: %d ip: %s   port: %d is connect\n",acceptfd, inet_ntoa(saddr.sin_addr), ntohs(saddr.sin_port));
    111.  
    112.                 event.data.fd = acceptfd;//新的acceptfd上树
    113.                 event.events = EPOLLIN | EPOLLET;
    114.                 epoll_ctl(epfd, EPOLL_CTL_ADD, acceptfd, &event);
    115.             }
    116.             else
    117.             {
    118.                 int recvbyte = recv(revents[i].data.fd, buf, sizeof(buf), 0);
    119.                 if (recvbyte < 0)
    120.                 {
    121.                     perror("recv is err:");
    122.                     return -1;
    123.                 }
    124.                 else if (recvbyte == 0)
    125.                 {
    126.                     printf("client is exit\n");
    127.                     close(revents[i].data.fd);
    128.                     epoll_ctl(epfd, EPOLL_CTL_DEL, revents[i].data.fd, NULL);
    129.                 }
    130.                 else
    131.                 {
    132.                     printf("%d : %s\n", revents[i].data.fd, buf);
    133.                 }
    134.             }
    135.         }
    136.     }
    137.     close(sockfd);
    138.     close(acceptfd);
    139.     return 0;
    140. }
    141.

  • 相关阅读:
    【图像分割】基于元胞自动机实现图像分割附matlab代码
    如何拿取 macOS 系统中的图标文件
    批量虚化边框并一键褪色的简单教程
    golang结构与接口方法实现与交互使用示例
    面向mMTC的5G网络多随机接入机制性能优化策略
    【PTHREAD】线程互斥与同步之读写锁
    HNUCM 您好中国
    Docker 启动容器
    知识图谱-KGE-对抗模型-2018：KBGAN
    代码优雅之道——Springboot统一返回结果
  • 原文地址：https://blog.csdn.net/m0_74937538/article/details/134326345