linux并发服务器epoll

た入场券 2022-11-30 12:50 191阅读 0赞

### 文章目录 ###

*  linux并发服务器epoll
 *  三个函数
 *   *  第一个函数 epoll\_create
     *  第二个函数 epoll\_ctl
     *   *  结构体
         *  参数
     *  第三个函数 epoll\_wait
     *   *  参数
 *  epoll模型
 *  代码
 *  epoll事件分发
 *  epoll三种工作模式
 *   *  水平触发模式 - 默认的工作模式
     *  边沿触发模式 - ET ev.events = EPOLLIN | EPOLLET;
     *  边沿非阻塞触发

# linux并发服务器epoll #

参考资料：  
[epoll的本质][epoll]  
[选择/轮询/ epoll：系统架构师的实际差异][epoll 1]

# 三个函数 #

## 第一个函数 epoll\_create ##

该函数生成一个epoll专用的文件描述符

#include <sys/epoll.h>
    int epoll_create(int size);

size: epoll 上能关注的最大描述符数

## 第二个函数 epoll\_ctl ##

用于控制某个epoll文件描述符事件，可以注册、修改、删除

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

### 结构体 ###

typedef union epoll_data { 
                   void        *ptr;
                   int          fd;
                   uint32_t     u32;
                   uint64_t     u64;
               } epoll_data_t;
    
               struct epoll_event { 
                   uint32_t     events;      /* Epoll events */
                   epoll_data_t data;        /* User data variable */
               };
    events:
           EPOLLIN ---读
                  The associated file is available for read(2) operations.
    
           EPOLLOUT ---写
                  The associated file is available for write(2) operations.
    
           EPOLLERR ---异常
                  Error condition happened on the associated file descriptor.

### 参数 ###

epfd : epoll_create生成的epoll专用描述符
    	   op:
           EPOLL_CTL_ADD ---注册
                  Register the target file descriptor fd on the epoll instance referred to by the file descriptor epfd and associate the event event with the internal file linked to fd.
    
           EPOLL_CTL_MOD ---修改
                  Change the event event associated with the target file descriptor fd.
    
           EPOLL_CTL_DEL ---删除
                  Remove (deregister) the target file descriptor fd from the epoll instance referred to by epfd.  The event is ignored and can be NULL (but see BUGS below).
    	  fd : 关联的文件描述符

## 第三个函数 epoll\_wait ##

等待IO事件发生——可以设置阻塞函数

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

对应select和poll函数

### 参数 ###

epfd:要检测的句柄  
events:用于回传等待处理事件的数组  
maxevents:告诉内核这个events的大小  
timeout:为超时时间  
\-1永久阻塞  
0:立即返回  
>:0

# epoll模型 #

int main()
    { 
        //创建监听的套接字
        int lfd = socket();
        //绑定
        bind();
        //监听
        listen();
    
        
        //epoll树根节点
        int epfd = epoll_create(3000);
        //存储发送变化的fd对应信息
        struct epoll_event all[3000];
        //init初始化
        //监听的lfd挂到epoll树上
        struct epoll_event ev;
        //在ev中init lfd信息
        ev.events = EPOLLIN;
        ev.data.fd = lfd;
        epoll_ctl(epfd,EPOLL_CTL_ADD,lfd,&ev);    
    
    
        while(1)
        { 
            //委托内核测事件
            int ret = epoll_wait(epfd,all,3000,-1);
            //根据ret遍历all数组
            for(int i = 0;i< ret ;++i  )
            { 
                in ffd = all[i].data.fd;
                //有新的连接
                if(fd == lfd)
                { 
                    //接收连接请求 -accept不阻塞
                    int cfd = accept();
                    //cfd上树
                    ev.events = EPOLLIN;
                    ev.data.fd = cfd;
                    epoll_ctl(epfd,EPOLL_CTL_ADD,cfd,&ev);
                }
                //已经连接的客户端有数据发送过来
                else
                { 
                    //只处理客户端发来的数据
                    if(!all[i].events & EPOLLIN )
                    { 
                        continue;
                    }
                    //读数据
                    int len = recv();
                    if(len == 0 )
                    { 
                        close(fd);
                        //检测的fd从树上删除
                        epoll_ctl(epfd,EPOLL_CTL_DEL,fd,NULL);
                    }
                    //写数据
                    send();
                }
            }
        }
    }

# 代码 #

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <ctype.h>
    #include <sys/epoll.h>
    
    
    int main(int argc, const char* argv[])
    { 
        if(argc < 2)
        { 
            printf("eg: ./a.out port\n");
            exit(1);
        }
        struct sockaddr_in serv_addr;
        socklen_t serv_len = sizeof(serv_addr);
        int port = atoi(argv[1]);
    
        // 创建套接字
        int lfd = socket(AF_INET, SOCK_STREAM, 0);
        // 初始化服务器 sockaddr_in 
        memset(&serv_addr, 0, serv_len);
        serv_addr.sin_family = AF_INET;                   // 地址族 
        serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);    // 监听本机所有的IP
        serv_addr.sin_port = htons(port);            // 设置端口 
        // 绑定IP和端口
        bind(lfd, (struct sockaddr*)&serv_addr, serv_len);
    
        // 设置同时监听的最大个数
        listen(lfd, 36);
        printf("Start accept ......\n");
    
        struct sockaddr_in client_addr;
        socklen_t cli_len = sizeof(client_addr);
    
        // 创建epoll树根节点
        int epfd = epoll_create(2000);
        // 初始化epoll树
        struct epoll_event ev;
        ev.events = EPOLLIN;
        ev.data.fd = lfd;
        epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);
    
        struct epoll_event all[2000];
        while(1)
        { 
            // 使用epoll通知内核fd 文件IO检测
            int ret = epoll_wait(epfd, all, sizeof(all)/sizeof(all[0]), -1);
    
            // 遍历all数组中的前ret个元素
            for(int i=0; i<ret; ++i)
            { 
                int fd = all[i].data.fd;
                // 判断是否有新连接
                if(fd == lfd)
                { 
                    // 接受连接请求
                    int cfd = accept(lfd, (struct sockaddr*)&client_addr, &cli_len);
                    if(cfd == -1)
                    { 
                        perror("accept error");
                        exit(1);
                    }
                    // 将新得到的cfd挂到树上
                    struct epoll_event temp;
                    temp.events = EPOLLIN;
                    temp.data.fd = cfd;
                    epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &temp);
                    
                    // 打印客户端信息
                    char ip[64] = { 0};
                    printf("New Client IP: %s, Port: %d\n",
                        inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ip, sizeof(ip)),
                        ntohs(client_addr.sin_port));
                    
                }
                else
                { 
                    // 处理已经连接的客户端发送过来的数据
                    if(!all[i].events & EPOLLIN) 
                    { 
                        continue;
                    }
    
                    // 读数据
                    char buf[1024] = { 0};
                    int len = recv(fd, buf, sizeof(buf), 0);
                    if(len == -1)
                    { 
                        perror("recv error");
                        exit(1);
                    }
                    else if(len == 0)
                    { 
                        printf("client disconnected ....\n");
                        // fd从epoll树上删除
                        ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                        if(ret == -1)
                        { 
                            perror("epoll_ctl - del error");
                            exit(1);
                        }
                        close(fd);
                        
                    }
                    else
                    { 
                        printf(" recv buf: %s\n", buf);
                        write(fd, buf, len);
                    }
                }
            }
        }
    
        close(lfd);
        return 0;
    }

# epoll事件分发 #

The epoll event distribution interface is able to behave both as edge-triggered (ET) and as level-triggered (LT).  The difference between the two mechanisms can be described as follows.   Suppose
           that this scenario happens:
    
           1. The file descriptor that represents the read side of a pipe (rfd) is registered on the epoll instance.
    
           2. A pipe writer writes 2 kB of data on the write side of the pipe.
    
           3. A call to epoll_wait(2) is done that will return rfd as a ready file descriptor.
    
           4. The pipe reader reads 1 kB of data from rfd.
    
           5. A call to epoll_wait(2) is done.

epoll事件分发接口可以作为边缘触发（ET）和级别触发（LT）两种方式。这两种机制的区别可以描述如下。假设  
发生这种情况：  
1表示管道（rfd）的读取端的文件描述符在epoll实例上注册。  
2管道编写器在管道的写入端写入2 kB的数据。  
3对epoll\_wait（2）的调用已完成，它将返回rfd作为就绪文件描述符。  
4管道读取器从rfd读取1kb的数据。  
5对epoll\_wait（2）的调用已完成。

# epoll三种工作模式 #

[参考——epoll三种工作模式][epoll 2]  
![epoll\_wait调用次数越多，系统的开销越大][epoll_wait]

1.水平触发模式 -根据读来解释

*  只要fd对应的缓冲区有数据
 *  epoll\_wait返回
 *  返回的次数与发送数据的次数没有关系
 *  epoll默认的工作模式

2.边沿触发模式 -ET

fd - 默认阻塞属性  
客户端给server发数据:  
 □ 发一次数据server 的 epoll\_wait返回一次  
 □ 不在乎数据是否读完  
 □ 如果读不完, 如何全部读出来?  
   while(recv());  
   数据读完之后recv会阻塞  
   解决阻塞问题  
    设置非阻塞 - fd

3.边沿非阻塞触发模式

*  效率最高
 *  如何设置非阻塞  
     open()  
      □ 设置flags  
      □ 必须 O\_WDRW | O\_NONBLOCK  
      □ 终端文件: /dev/tty  
     fcntl()  
      □ int flag = fcntl(fd, F\_GETFL);  
      □ flag |= O\_NONBLOCK;  
      □ fcntl(fd, F\_SETFL, flag);
 *  将缓冲区的全部数据都读出

while(recv() > 0)
    { 
    	printf(): 
    }

当缓冲区数据读完之后，返回是否为０？

## 水平触发模式 - 默认的工作模式 ##

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <ctype.h>
    #include <sys/epoll.h>
     
     
    int main(int argc, const char* argv[])
    { 
        if(argc < 2)
        { 
            printf("eg: ./a.out port\n");
            exit(1);
        }
        struct sockaddr_in serv_addr;
        socklen_t serv_len = sizeof(serv_addr);
        int port = atoi(argv[1]);
     
        // 创建套接字
        int lfd = socket(AF_INET, SOCK_STREAM, 0);
        // 初始化服务器 sockaddr_in 
        memset(&serv_addr, 0, serv_len);
        serv_addr.sin_family = AF_INET;                   // 地址族 
        serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);    // 监听本机所有的IP
        serv_addr.sin_port = htons(port);            // 设置端口 
        // 绑定IP和端口
        bind(lfd, (struct sockaddr*)&serv_addr, serv_len);
     
        // 设置同时监听的最大个数
        listen(lfd, 36);
        printf("Start accept ......\n");
     
        struct sockaddr_in client_addr;
        socklen_t cli_len = sizeof(client_addr);
     
        // 创建epoll树根节点
        int epfd = epoll_create(2000);
        // 初始化epoll树
        struct epoll_event ev;
        ev.events = EPOLLIN;
        ev.data.fd = lfd;
        epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);
     
        struct epoll_event all[2000];
        while(1)
        { 
            // 使用epoll通知内核fd 文件IO检测
            int ret = epoll_wait(epfd, all, sizeof(all)/sizeof(all[0]), -1);
            printf("================== epoll_wait =============\n");
     
            // 遍历all数组中的前ret个元素
            for(int i=0; i<ret; ++i)
            { 
                int fd = all[i].data.fd;
                // 判断是否有新连接
                if(fd == lfd)
                { 
                    // 接受连接请求
                    int cfd = accept(lfd, (struct sockaddr*)&client_addr, &cli_len);
                    if(cfd == -1)
                    { 
                        perror("accept error");
                        exit(1);
                    }
                    // 将新得到的cfd挂到树上
                    struct epoll_event temp;
                    temp.events = EPOLLIN;
                    temp.data.fd = cfd;
                    epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &temp);
                    
                    // 打印客户端信息
                    char ip[64] = { 0};
                    printf("New Client IP: %s, Port: %d\n",
                        inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ip, sizeof(ip)),
                        ntohs(client_addr.sin_port));
                    
                }
                else
                { 
                    // 处理已经连接的客户端发送过来的数据
                    if(!all[i].events & EPOLLIN) 
                    { 
                        continue;
                    }
     
                    // 读数据
                    char buf[5] = { 0};
                    int len = recv(fd, buf, sizeof(buf), 0);
                    if(len == -1)
                    { 
                        perror("recv error");
                        exit(1);
                    }
                    else if(len == 0)
                    { 
                        printf("client disconnected ....\n");
                        // fd从epoll树上删除
                        ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                        if(ret == -1)
                        { 
                            perror("epoll_ctl - del error");
                            exit(1);
                        }
                        close(fd);
                        
                    }
                    else
                    { 
                        // printf(" recv buf: %s\n", buf);
                        write(STDOUT_FILENO, buf, len);
                        write(fd, buf, len);
                    }
                }
            }
        }
     
        close(lfd);
        return 0;
    }

## 边沿触发模式 - ET ev.events = EPOLLIN | EPOLLET; ##

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <ctype.h>
    #include <sys/epoll.h>
     
     
    int main(int argc, const char* argv[])
    { 
        if(argc < 2)
        { 
            printf("eg: ./a.out port\n");
            exit(1);
        }
        struct sockaddr_in serv_addr;
        socklen_t serv_len = sizeof(serv_addr);
        int port = atoi(argv[1]);
     
        // 创建套接字
        int lfd = socket(AF_INET, SOCK_STREAM, 0);
        // 初始化服务器 sockaddr_in 
        memset(&serv_addr, 0, serv_len);
        serv_addr.sin_family = AF_INET;                   // 地址族 
        serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);    // 监听本机所有的IP
        serv_addr.sin_port = htons(port);            // 设置端口 
        // 绑定IP和端口
        bind(lfd, (struct sockaddr*)&serv_addr, serv_len);
     
        // 设置同时监听的最大个数
        listen(lfd, 36);
        printf("Start accept ......\n");
     
        struct sockaddr_in client_addr;
        socklen_t cli_len = sizeof(client_addr);
     
        // 创建epoll树根节点
        int epfd = epoll_create(2000);
        // 初始化epoll树
        struct epoll_event ev;
     
        // 设置边沿触发
        ev.events = EPOLLIN | EPOLLET;
        ev.data.fd = lfd;
        epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);
     
        struct epoll_event all[2000];
        while(1)
        { 
            // 使用epoll通知内核fd 文件IO检测
            int ret = epoll_wait(epfd, all, sizeof(all)/sizeof(all[0]), -1);
            printf("================== epoll_wait =============\n");
     
            // 遍历all数组中的前ret个元素
            for(int i=0; i<ret; ++i)
            { 
                int fd = all[i].data.fd;
                // 判断是否有新连接
                if(fd == lfd)
                { 
                    // 接受连接请求
                    int cfd = accept(lfd, (struct sockaddr*)&client_addr, &cli_len);
                    if(cfd == -1)
                    { 
                        perror("accept error");
                        exit(1);
                    }
                    // 将新得到的cfd挂到树上
                    struct epoll_event temp;
                    // 设置边沿触发
                    temp.events = EPOLLIN | EPOLLET;
                    temp.data.fd = cfd;
                    epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &temp);
                    
                    // 打印客户端信息
                    char ip[64] = { 0};
                    printf("New Client IP: %s, Port: %d\n",
                        inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ip, sizeof(ip)),
                        ntohs(client_addr.sin_port));
                    
                }
                else
                { 
                    // 处理已经连接的客户端发送过来的数据
                    if(!all[i].events & EPOLLIN) 
                    { 
                        continue;
                    }
     
                    // 读数据
                    char buf[5] = { 0};
                    int len = recv(fd, buf, sizeof(buf), 0);
                    if(len == -1)
                    { 
                        perror("recv error");
                        exit(1);
                    }
                    else if(len == 0)
                    { 
                        printf("client disconnected ....\n");
                        // fd从epoll树上删除
                        ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                        if(ret == -1)
                        { 
                            perror("epoll_ctl - del error");
                            exit(1);
                        }
                        close(fd);
                        
                    }
                    else
                    { 
                        // printf(" recv buf: %s\n", buf);
                        write(STDOUT_FILENO, buf, len);
                        write(fd, buf, len);
                    }
                }
            }
        }
     
        close(lfd);
        return 0;
    }

## 边沿非阻塞触发 ##

#include <stdio.h>
    #include <unistd.h>
    #include <stdlib.h>
    #include <sys/types.h>
    #include <string.h>
    #include <sys/socket.h>
    #include <arpa/inet.h>
    #include <ctype.h>
    #include <sys/epoll.h>
    #include <fcntl.h>
    #include <errno.h>
     
    int main(int argc, const char* argv[])
    { 
        if(argc < 2)
        { 
            printf("eg: ./a.out port\n");
            exit(1);
        }
        struct sockaddr_in serv_addr;
        socklen_t serv_len = sizeof(serv_addr);
        int port = atoi(argv[1]);
     
        // 创建套接字
        int lfd = socket(AF_INET, SOCK_STREAM, 0);
        // 初始化服务器 sockaddr_in 
        memset(&serv_addr, 0, serv_len);
        serv_addr.sin_family = AF_INET;                   // 地址族 
        serv_addr.sin_addr.s_addr = htonl(INADDR_ANY);    // 监听本机所有的IP
        serv_addr.sin_port = htons(port);            // 设置端口 
        // 绑定IP和端口
        bind(lfd, (struct sockaddr*)&serv_addr, serv_len);
     
        // 设置同时监听的最大个数
        listen(lfd, 36);
        printf("Start accept ......\n");
     
        struct sockaddr_in client_addr;
        socklen_t cli_len = sizeof(client_addr);
     
        // 创建epoll树根节点
        int epfd = epoll_create(2000);
        // 初始化epoll树
        struct epoll_event ev;
     
        // 设置边沿触发
        ev.events = EPOLLIN;
        ev.data.fd = lfd;
        epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);
     
        struct epoll_event all[2000];
        while(1)
        { 
            // 使用epoll通知内核fd 文件IO检测
            int ret = epoll_wait(epfd, all, sizeof(all)/sizeof(all[0]), -1);
            printf("================== epoll_wait =============\n");
     
            // 遍历all数组中的前ret个元素
            for(int i=0; i<ret; ++i)
            { 
                int fd = all[i].data.fd;
                // 判断是否有新连接
                if(fd == lfd)
                { 
                    // 接受连接请求
                    int cfd = accept(lfd, (struct sockaddr*)&client_addr, &cli_len);
                    if(cfd == -1)
                    { 
                        perror("accept error");
                        exit(1);
                    }
                    // 设置文件cfd为非阻塞模式
                    int flag = fcntl(cfd, F_GETFL);
                    flag |= O_NONBLOCK;
                    fcntl(cfd, F_SETFL, flag);
     
                    // 将新得到的cfd挂到树上
                    struct epoll_event temp;
                    // 设置边沿触发
                    temp.events = EPOLLIN | EPOLLET;
                    temp.data.fd = cfd;
                    epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &temp);
                    
                    // 打印客户端信息
                    char ip[64] = { 0};
                    printf("New Client IP: %s, Port: %d\n",
                        inet_ntop(AF_INET, &client_addr.sin_addr.s_addr, ip, sizeof(ip)),
                        ntohs(client_addr.sin_port));
                    
                }
                else
                { 
                    // 处理已经连接的客户端发送过来的数据
                    if(!all[i].events & EPOLLIN) 
                    { 
                        continue;
                    }
     
                    // 读数据
                    char buf[5] = { 0};
                    int len;
                    // 循环读数据
                    while( (len = recv(fd, buf, sizeof(buf), 0)) > 0 )
                    { 
                        // 数据打印到终端
                        write(STDOUT_FILENO, buf, len);
                        // 发送给客户端
                        send(fd, buf, len, 0);
                    }
                    if(len == 0)
                    { 
                        printf("客户端断开了连接\n");
                        ret = epoll_ctl(epfd, EPOLL_CTL_DEL, fd, NULL);
                        if(ret == -1)
                        { 
                            perror("epoll_ctl - del error");
                            exit(1);
                        }
                        close(fd);
                    }
                    else if(len == -1)
                    { 
                        if(errno == EAGAIN)
                        { 
                            printf("缓冲区数据已经读完\n");
                        }
                        else
                        { 
                            printf("recv error----\n");
                            exit(1);
                        }
                    }
                }
            }
        }
     
        close(lfd);
        return 0;
    }

[epoll]: https://www.toutiao.com/i6683264188661367309/
[epoll 1]: https://www.ulduzsoft.com/2014/01/select-poll-epoll-practical-difference-for-system-architects/
[epoll 2]: https://blog.csdn.net/qq1113231395/article/details/89447614
[epoll_wait]: /images/20221123/c788d7779a154574acb855f46c6a52cc.png