• I/O多路复用技术

    目录

    1.select/poll简介

    2.epoll（重点） 

    2.1epoll简介

    2.2函数原型

    epoll_create

    epoll_event

    epoll_ctl

    epoll_wait

    fcntl

    2.3epoll的两种工作模式以及对应的案例

    LT模式(水平触发模式)

    ET模式(边沿触发模式)

    1.select/poll简介

    poll是对select缺点进行一个改进(没有解决内核态和用户态转变的问题，只是解决了1024比特位的限制以及不能重用每次都需要重置的问题。

    2.epoll（重点） 

    2.1epoll简介

     

     rbr红黑树+rdlist双链表

    2.2函数原型

    epoll_create

    1. #include 
    2. int epoll_create(int size);

    创建一个新的epoll实例。在内核中创建了一个数据，这个数据中有两个比较重要的数据，一个是需要检测的文件描述符的信息（红黑树），还有一个是就绪列表，存放检测到数据发送改变的文件描述符信息（双向链表）。

    - 参数：

            size : 目前没有意义了。随便写一个数，必须大于0

    - 返回值：

            -1 : 失败

            > 0 : 文件描述符，操作epoll实例的

    epoll_event

    1. struct epoll_event {
    2.     uint32_t events; /* Epoll events */
    3.     epoll_data_t data; /* User data variable */
    4. };

    常见的Epoll检测事件：

    - EPOLLIN

    - EPOLLOUT

    - EPOLLERR

    - EPOLLET

    epoll_ctl

    int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);

    - 参数：

            - epfd : epoll实例对应的文件描述符

            - op : 要进行什么操作 EPOLL_CTL_ADD: 添加 EPOLL_CTL_MOD: 修改 EPOLL_CTL_DEL: 删除

            - fd : 要检测的文件描述符

            - event : 检测文件描述符什么事情

    epoll_wait

    int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);

    - 参数：

            - epfd : epoll实例对应的文件描述符

            - events : 传出参数，保存了发送了变化的文件描述符的信息

            - maxevents : 第二个参数结构体数组的大小

            - timeout : 阻塞时间 - 0 : 不阻塞 - -1 : 阻塞，直到检测到fd数据发生变化，解除阻塞 - > 0 : 阻塞的时长（毫秒）

            - 返回值： - 成功，返回发送变化的文件描述符的个数 > 0 - 失败 -1

    fcntl

    1. #include 
    2. #include 
    3. int fcntl(int fd, int cmd, ...  );

    参数:
            fd:表示需要操作的文件描述符
            cmd:表示对文件描述符进行如何操作
                1.F_DUPFD:复制文件描述符,复制的是第一个参数fd，得到一个新的文件描述符
                    int ret = fcntl(fd,F_DUPFD);
                2.F_GETFL:获取指定的文件描述符文件状态flag
                    获取的flag和我们通过open函数传递的flag是一个东西
                3.F_SETFL：设置文件描述符文件状态flag
                    必选项:O_RDONLY,O_WRONDLY,O_RDWR 不可以被修改
                    可选项:O_APPEND,O_NONBLOCK
                        O_APPEND 表示追加数据
                        O_NONBLOCK 设置成非阻塞 

    2.3epoll的两种工作模式以及对应的案例

    LT模式(水平触发模式)

    假设委托内核检测读事件 -> 检测fd的读缓冲区 读缓冲区有数据 - > epoll检测到了会给用户通知

    a.用户不读数据，数据一直在缓冲区，epoll 会一直通知

    b.用户只读了一部分数据，epoll会通知

    c.缓冲区的数据读完了，不通知

    LT（level - triggered）是缺省的工作方式，并且同时支持 block和no-block socket。在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作，内核还是会继续通知你的。 

    服务器案例

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7.  
    8. int main()
    9. {
    10.     //1.创建socket
    11.     int lfd = socket(AF_INET,SOCK_STREAM,0);
    12.     if(lfd==-1){
    13.         perror("socket");
    14.         exit(-1);
    15.     }
    16.     printf("创建socket成功\n");
    17.     
    18.     //2.绑定
    19.     struct sockaddr_in saddr;
    20.     saddr.sin_family=AF_INET;
    21.     saddr.sin_port=htons(9999);
    22.     saddr.sin_addr.s_addr=INADDR_ANY;
    23.     int ret=bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));
    24.     if(ret==-1){
    25.         perror("bind");
    26.         exit(-1);
    27.     }
    28.     printf("绑定成功\n");
    29.  
    30.     //3.监听
    31.     ret=listen(lfd,10);
    32.     if(ret==-1){
    33.         perror("listen");
    34.         exit(-1);
    35.     }
    36.     printf("监听成功\n");
    37.  
    38.     //4.创建epoll实例
    39.     int epfd=epoll_create(1);
    40.     if(epfd==-1){
    41.         perror("epoll_create");
    42.         exit(-1);
    43.     }
    44.     printf("创建epoll实例成功\n");
    45.  
    46.     //5.加入监听的文件描述相关信息
    47.     struct epoll_event epev;
    48.     epev.events=EPOLLIN;
    49.     epev.data.fd=lfd;
    50.     epoll_ctl(epfd,EPOLL_CTL_ADD,lfd,&epev);
    51.  
    52.     struct epoll_event epevs[1024];
    53.     while(1){
    54.         ret = epoll_wait(epfd,epevs,1024,-1);
    55.         if(ret == -1){
    56.             perror("epoll_wait");
    57.             exit(-1);
    58.         }
    59.         printf("ret = %d\n",ret);
    60.         for(int i=0;i
    61.             int curfd=epevs[i].data.fd;
    62.             if(curfd==lfd){
    63.                 struct sockaddr_in cliaddr;
    64.                 int len = sizeof(cliaddr);
    65.                 int cfd = accept(lfd,(struct sockaddr*)&cliaddr,&len);
    66.                 epev.events=EPOLLIN;
    67.                 epev.data.fd=cfd;
    68.                 epoll_ctl(epfd,EPOLL_CTL_ADD,cfd,&epev);
    69.             }else {
    70.                 if(epevs[i].events&EPOLLOUT){
    71.                     continue;
    72.                 }
    73.                 //有数据到达需要通信
    74.                 char buf[1024]={0};
    75.                 int len = read(curfd,buf,sizeof(buf));
    76.                 if(len==-1){
    77.                     perror("read");
    78.                     exit(-1);
    79.                 }
    80.                 else if(len==0){
    81.                     printf("client closed...\n");
    82.                     epoll_ctl(epfd,EPOLL_CTL_DEL,curfd,NULL);
    83.                     close(curfd);
    84.                 }
    85.                 else if(len>0){
    86.                     printf("read buf = %s\n",buf);
    87.                     memset(buf,0,sizeof (buf));
    88.                     sprintf(buf,"recv");
    89.                     write(curfd,buf,strlen(buf)+1);
    90.                 }
    91.             }
    92.         }
    93.     }
    94.     close(lfd);
    95.     close(epfd);
    96.     return 0;
    97. }

    客户端案例

    1. #include
    2. #include
    3. #include
    4. #include // read write close
    5. #include
    6. int main()
    7. {
    8.     //1.创建套接字
    9.     int cfd=socket(AF_INET,SOCK_STREAM,0);
    10.     if(cfd==-1){
    11.         perror("socket");
    12.         exit(0);
    13.     }
    14.     printf("1.客户端创建套接字成功\n");
    15.  
    16.     //2.连接服务器
    17.     struct sockaddr_in saddr;
    18.     saddr.sin_family=AF_INET;
    19.     saddr.sin_port=htons(9999);
    20.     inet_pton(AF_INET,"192.168.108.128",&saddr.sin_addr);//服务器的ip地址
    21.     /*
    22.     p:点分十进制的IP字符串，n:表示network，网络字节序的整数
    23.         int inet_pton(int af, const char *src, void *dst);
    24.         af:地址族： AF_INET AF_INET6
    25.         src:需要转换的点分十进制的IP字符串
    26.         dst:转换后的结果保存在这个里面
    27.     */
    28.     int ret=connect(cfd,(struct sockaddr*)&saddr,sizeof(saddr));
    29.  
    30.     if(ret==-1){
    31.         perror("connect");
    32.         exit(-1);
    33.     }
    34.     printf("2.客户端服务器连接成功\n");
    35.  
    36.     //3.通信
    37.     char recvBuf[1024]={0};
    38.     while(1){
    39.         printf("请输入你想要发给服务端的内容\n");
    40.         memset(recvBuf,0,sizeof(recvBuf));
    41.         scanf("%s",recvBuf);
    42.         write(cfd,recvBuf,strlen(recvBuf)+1);
    43.         memset(recvBuf,0,sizeof(recvBuf));
    44.         int data=read(cfd,recvBuf,sizeof(recvBuf));
    45.         if(data>0)
    46.         {
    47.             printf("服务端返回数据:%s\n",recvBuf);
    48.         }
    49.         else if(data==0){
    50.             printf("服务端断开连接\n");
    51.         }else if(data<0){
    52.             perror("read");
    53.             exit(-1);
    54.         }
    55.     }
    56.     close(cfd);
    57.     return 0;
    58. }

    ET模式(边沿触发模式)

    假设委托内核检测读事件 -> 检测fd的读缓冲区 读缓冲区有数据 - > epoll检测到了会给用户通知

    a.用户不读数据，数据一致在缓冲区中，epoll下次检测的时候就不通知了

    b.用户只读了一部分数据，epoll不通知

    c.缓冲区的数据读完了，不通知

    ET（edge - triggered）是高速工作方式，只支持 no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了。但是请注意，如果一直不对这个fd作IO操作（从而导致它再次变成未就绪），内核不会发送更多的通知（only once）。ET 模式在很大程度上减少了epoll 事件被重复触发的次数，因此效率要比 LT 模式高。epoll工作在 ET 模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。

    服务器案例:

    1. #include
    2. #include
    3. #include
    4. #include
    5. #include
    6. #include
    7. #include
    8. #include
    9.  
    10. int main(){
    11.  
    12.     int lfd = socket(AF_INET,SOCK_STREAM,0);
    13.     if(lfd==-1){
    14.         perror("socket");
    15.         exit(-1);
    16.     }
    17.     printf("服务器创建socket成功\n");
    18.  
    19.     struct sockaddr_in saddr;
    20.     saddr.sin_addr.s_addr=INADDR_ANY;
    21.     saddr.sin_family=AF_INET;
    22.     saddr.sin_port=htons(9999);
    23.     int ret=bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));
    24.     if(ret == -1){
    25.         perror("bind");
    26.         exit(-1);
    27.     }
    28.     printf("socket绑定成功\n");
    29.  
    30.     ret = listen(lfd,8);
    31.     if(ret == -1){
    32.         perror("listen");
    33.         exit(-1);
    34.     }
    35.     printf("监听套接字成功\n");
    36.  
    37.     int epfd = epoll_create(1);
    38.     if(epfd==-1){
    39.         perror("epoll_create");
    40.         exit(-1);
    41.     }
    42.     struct epoll_event epev;
    43.     epev.events=EPOLLIN;
    44.     epev.data.fd=lfd;
    45.     ret = epoll_ctl(epfd,EPOLL_CTL_ADD,lfd,&epev);
    46.  
    47.     struct epoll_event epevs[1024];
    48.     while(1){
    49.         ret = epoll_wait(epfd,epevs,1024,-1);
    50.         if(ret == -1){
    51.             perror("epoll_wait");
    52.             exit(-1);
    53.         }
    54.  
    55.         printf("ret = %d\n",ret);
    56.         for(int i=0;i
    57.             int curfd=epevs[i].data.fd;
    58.             if(curfd==lfd){
    59.                 struct sockaddr_in cliaddr;
    60.                 int len = sizeof(cliaddr);
    61.                 int cfd = accept(lfd,(struct sockaddr*)&cliaddr,&len);
    62.  
    63.                 //这里是设置cfd属性非阻塞 因为et模式只支持文件非阻塞
    64.                 int flag = fcntl(cfd,F_GETFL);
    65.                 flag |= O_NONBLOCK;
    66.  
    67.                 epev.events=EPOLLIN|EPOLLET;//设置et模式
    68.                 epev.data.fd=cfd;
    69.                 epoll_ctl(epfd,EPOLL_CTL_ADD,cfd,&epev);
    70.             }else{
    71.                 if(epevs[i].events&EPOLLOUT){
    72.                     continue;
    73.                 }
    74.  
    75.                 //循环读取所有的数据
    76.                 char buf[5];
    77.                 int len=0;
    78.                 while((len=read(curfd,buf,sizeof(buf)))>0){
    79.                     //打印数据
    80.                     write(STDOUT_FILENO,buf,len);
    81.                     write(curfd,buf,len);
    82.                 }
    83.                 puts("");
    84.                 if(len==0){
    85.                     printf("连接断开\n");
    86.                 }else if(len==-1){
    87.                     if(errno==EAGAIN){
    88.                         printf("数据过多\n");
    89.                     }else{
    90.                         perror("read");
    91.                         exit(-1);
    92.                     }
    93.                 }
    94.             }
    95.         }
    96.     }   
    97.     close(lfd);
    98.     close(epfd);
    99.     return 0;
    100. }

  • 相关阅读:
    apple pencil一定要买吗？Ipad电容笔推荐品牌
    数据分享|SAS数据挖掘EM贷款违约预测分析：逐步Logistic逻辑回归、决策树、随机森林...
    Unity DOTS中的baking（五）prefabs
    Python线程（thread）
    我的创作纪念日 - 一周年 【2022-09-17】
    Blob把html导出为excel文件
    [Python]Open CV 基础知识学习
    阿里云原生应用平台架构师田伟：应用架构的规划、治理与演进
    环境变量简单解释
    MATLAB主窗口与编辑器窗口分开为两个界面的解决办法
  • 原文地址：https://blog.csdn.net/l_ethan/article/details/125988385