1.4 epoll
1.4.1、epoll API介绍
- 首先调用epoll_create()创建一个epoll实例----在内核区，是一个eventpoll结构体类型；返回值是一个文件描述符，可以通过这个文件描述符操作内核中这块内存（通过epoll提供的API进行操作）
- 生成的eventpoll内部，有两个类型：
- rb_root，红黑树结构；–记录需要检测的文件描述符
- list_head，链表 --要求检测的文件描述符中，哪些文件描述符是有数据的
优点： 与select和poll相比，直接在内核中创建一块内存，没有用户态到内核态的开销。
-
委托内核检测，epoll_ctl()函数
-
epollfd就是epoll_create()函数的返回值；
-
EPOLL_CTL_ADD：指定做什么操作
-
lfd：需要检测的文件描述符
-
ev：内核需要检测的事件；
ev参数的类型是：epoll_event
ev.events = EPOLLIN，检测读事件；
ev.data.fd = lfd，检测的文件描述符值
-
注意：现在只是将需要检测的文件描述符添加到红黑树rbr结构中；–比如添加了5个需要检测。
-
epoll_wait()，调用后，内核就会在内核中的红黑树结构中进行检测；
比如红黑树中需要检测5个文件描述符，有3个文件描述符发生了变化，将这3个文件描述符添加到链表rdlist中；
并且rdlist中数据会返回出去，速度是很快的（注意：可以返回具体是哪几个文件描述符）
#include <sys/epoll.h>
// 创建一个新的epoll实例。在内核中创建了一个数据，这个数据中有两个比较重要的数据，一个是需要检测的文件描述符的信息（红黑树），还有一个是就绪列表，存放检测到数据发送改变的文件描述符信息（双向链表）。
int epoll_create(int size);
- 参数：
size : 目前没有意义了。随便写一个数，必须大于0
- 返回值：
-1 : 失败
> 0 : 文件描述符，操作epoll实例的,(通过epfd就会找到内核中的数据)
typedef union epoll_data { --联合体，一个变量存在就行
void *ptr;
int fd; --一般用fd
uint32_t u32;
uint64_t u64;
} epoll_data_t;
//epoll_event结构体
struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */ --epoll_data_t是一个结构体
};
常见的Epoll检测事件：
- EPOLLIN
- EPOLLOUT
- EPOLLERR
...
// 对epoll实例进行管理：添加文件描述符信息，删除信息，修改信息 --(将需要检测的文件描述符添加到内核的红黑树中)
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 : 检测文件描述符什么事情
// 检测函数
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
- 参数:
- epfd : epoll实例对应的文件描述符
- events : 传出参数，保存了发送了变化的文件描述符的信息
- maxevents : 第二个参数结构体数组的大小
- timeout : 阻塞时间
- 0 : 不阻塞
- -1 : 阻塞，直到检测到fd数据发生变化，解除阻塞
- > 0 : 阻塞的时长（毫秒）
- 返回值:
- 成功，返回发送变化的文件描述符的个数 > 0
- 失败 -1
1.4.2、epoll 代码
//服务端
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
int main() {
// 创建socket
int lfd = socket(PF_INET, SOCK_STREAM, 0);
struct sockaddr_in saddr;
saddr.sin_port = htons(9999);
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = INADDR_ANY;
// 绑定
bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
// 监听
listen(lfd, 8);
// 调用epoll_create()创建一个epoll实例
int epfd = epoll_create(100); --通过epfd操作内核中的epoll实例
// 将监听的文件描述符相关的检测信息添加到epoll实例中
struct epoll_event epev;
epev.events = EPOLLIN; --检测读事件
epev.data.fd = lfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &epev);
struct epoll_event epevs[1024]; --传出参数，这个大小可以随便指定
while(1) {
int ret = epoll_wait(epfd, epevs, 1024, -1); --内核将有数据变化的文件描述符放到epevs中，-1表示阻塞
//ret表示发生改变的文件描述符的数目
if(ret == -1) {
perror("epoll_wait");
exit(-1);
}
printf("ret = %d\n", ret); --打印发生数据变化的文件描述符的个数
for(int i = 0; i < ret; i++) {
int curfd = epevs[i].data.fd; --epevs返回的给用户的，发生变化的文件描述符
if(curfd == lfd) {
// 监听的文件描述符有数据达到，有客户端连接
struct sockaddr_in cliaddr;
int len = sizeof(cliaddr);
int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
//将cfd文件描述符加入内核epoll实例中进行检测
epev.events = EPOLLIN; --检测读事件，就是有数据到达了;
//如果同时有读事件，也有写事件; epev.events = EPOLLIN | EPOLLOUT;
epev.data.fd = cfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);
} else {
//这个是针对既要检测读事件，也要写检测写事件，需要将写事件过滤掉
if(epevs[i].events & EPOLLOUT) {
continue;
}
// 有数据到达，需要通信
char buf[1024] = {0};
int len = read(curfd, buf, sizeof(buf));
if(len == -1) {
perror("read");
exit(-1);
} else if(len == 0) {
printf("client closed...\n");
epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL); --从内核epoll实例的红黑树中移除
close(curfd); --再将这个文件描述符关闭
} else if(len > 0) {
printf("read buf = %s\n", buf);
write(curfd, buf, strlen(buf) + 1);
}
}
}
}
close(lfd);
close(epfd); --关闭epoll的文件描述符;
return 0;
}
程序运行：
启动客户端：
服务端：
1.4.3、epoll两种工作模式
1.4.3.1、LT模式（水平触发）
假设委托内核检测读事件 -> 检测fd的读缓冲区
读缓冲区有数据 - > epoll检测到了会给用户通知
a. 用户不读数据，数据一直在缓冲区，epoll 会一直通知；
b. 用户只读了一部分数据，epoll会通知；
c. 缓冲区的数据读完了，不通知；
- LT（level - triggered）是缺省的工作方式(默认)，并且同时支持 block 和 no-block socket(非阻塞)。
- 在这种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的 fd 进行 IO 操作。如果你不作任何操作，内核还是会继续通知你的。
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
int main() {
// 创建socket
int lfd = socket(PF_INET, SOCK_STREAM, 0);
struct sockaddr_in saddr;
saddr.sin_port = htons(9999);
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = INADDR_ANY;
// 绑定
bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
// 监听
listen(lfd, 8);
// 调用epoll_create()创建一个epoll实例
int epfd = epoll_create(100);
// 将监听的文件描述符相关的检测信息添加到epoll实例中
struct epoll_event epev;
epev.events = EPOLLIN;
epev.data.fd = lfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &epev);
struct epoll_event epevs[1024];
while(1) {
int ret = epoll_wait(epfd, epevs, 1024, -1);
if(ret == -1) {
perror("epoll_wait");
exit(-1);
}
printf("ret = %d\n", ret);
for(int i = 0; i < ret; i++) {
int curfd = epevs[i].data.fd;
if(curfd == lfd) {
// 监听的文件描述符有数据达到，有客户端连接
struct sockaddr_in cliaddr;
int len = sizeof(cliaddr);
int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
epev.events = EPOLLIN;
epev.data.fd = cfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);
} else {
if(epevs[i].events & EPOLLOUT) {
continue;
}
// 有数据到达，需要通信
char buf[5] = {0};
int len = read(curfd, buf, sizeof(buf));
if(len == -1) {
perror("read");
exit(-1);
} else if(len == 0) {
printf("client closed...\n");
epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
close(curfd);
} else if(len > 0) {
printf("read buf = %s\n", buf);
write(curfd, buf, strlen(buf) + 1);
}
}
}
}
close(lfd);
close(epfd);
return 0;
}
#include <stdio.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
int main() {
// 创建socket
int fd = socket(PF_INET, SOCK_STREAM, 0);
if(fd == -1) {
perror("socket");
return -1;
}
struct sockaddr_in seraddr;
inet_pton(AF_INET, "127.0.0.1", &seraddr.sin_addr.s_addr);
seraddr.sin_family = AF_INET;
seraddr.sin_port = htons(9999);
// 连接服务器
int ret = connect(fd, (struct sockaddr *)&seraddr, sizeof(seraddr));
if(ret == -1){
perror("connect");
return -1;
}
int num = 0;
while(1) {
char sendBuf[1024] = {0};
// sprintf(sendBuf, "send data %d", num++);
fgets(sendBuf, sizeof(sendBuf), stdin); --通过键盘录入数据
write(fd, sendBuf, strlen(sendBuf) + 1);
// 接收
int len = read(fd, sendBuf, sizeof(sendBuf));
if(len == -1) {
perror("read");
return -1;
}else if(len > 0) {
printf("read buf = %s\n", sendBuf);
} else {
printf("服务器已经断开连接...\n");
break;
}
}
close(fd);
return 0;
}
程序运行：
客户端连接进来，但是还没有录入数据，客户端处于阻塞状态。
ret = 1；表示有自己的服务端的监听的文件描述符发生了变化，说明有客户端连进来了。
客户端录入数据：
服务端结果：
每次打印一次ret = 1（这里的ret=1，客户端和服务端建立连接的文件描述符发生变化了）；表示内核检测一次数据；就是要检测文件描述符缓冲区的数据没有读完，就会一直通知你；
1.4.3.2、ET模式（边沿触发）
假设委托内核检测读事件 -> 检测fd的读缓冲区
读缓冲区有数据 - > epoll检测到了会给用户通知（epoll只会通知一次）
a.用户不读数据，数据一致在缓冲区中，epoll下次检测的时候就不通知了；
b.用户只读了一部分数据，epoll不通知；
c.缓冲区的数据读完了，不通知；
ET（edge - triggered）是高速工作方式，只支持 no-block socket。在这种模式下，当描述符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述符不再为就绪状态了。但是请注意，如果一直不对这个 fd 作 IO 操作（从而导致它再次变成未就绪），内核不会发送更多的通知（only once）。
ET 模式在很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。epoll工作在 ET 模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死。（防止一个文件描述复读阻塞在哪里，其他文件描述符的事件不执行；因此需要设置ET模式-非阻塞套接字口。）
内核检测到文件描述符中有数据，只会通知你一次，数据没读完，不会再通知你了（水平模式会继续通知你）；
只有将这次数据读完了，后面文件描述符中有新数据时，ET模式下，才会继续通知你；
所以，我们要在内核通知的这一次中，将数据全部读出来。
struct epoll_event {
uint32_t events; /* Epoll events */
epoll_data_t data; /* User data variable */
};
常见的Epoll检测事件:
- EPOLLIN
- EPOLLOUT
- EPOLLERR
- EPOLLET --边沿触发
不完整的ET模式：只加了一个ET模式
epev.events = EPOLLIN | EPOLLET; --设置边沿模式
有问题的ET代码：
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
int main() {
// 创建socket
int lfd = socket(PF_INET, SOCK_STREAM, 0);
struct sockaddr_in saddr;
saddr.sin_port = htons(9999);
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = INADDR_ANY;
// 绑定
bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
// 监听
listen(lfd, 8);
// 调用epoll_create()创建一个epoll实例
int epfd = epoll_create(100);
// 将监听的文件描述符相关的检测信息添加到epoll实例中
struct epoll_event epev;
epev.events = EPOLLIN;
epev.data.fd = lfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &epev);
struct epoll_event epevs[1024];
while(1) {
int ret = epoll_wait(epfd, epevs, 1024, -1);
if(ret == -1) {
perror("epoll_wait");
exit(-1);
}
printf("ret = %d\n", ret);
for(int i = 0; i < ret; i++) {
int curfd = epevs[i].data.fd;
if(curfd == lfd) {
// 监听的文件描述符有数据达到，有客户端连接
struct sockaddr_in cliaddr;
int len = sizeof(cliaddr);
int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
epev.events = EPOLLIN | EPOLLET; --设置边沿模式
epev.data.fd = cfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);
} else {
if(epevs[i].events & EPOLLOUT) {
continue;
}
// 有数据到达，需要通信
char buf[5] = {0};
int len = read(curfd, buf, sizeof(buf));
if(len == -1) {
perror("read");
exit(-1);
} else if(len == 0) {
printf("client closed...\n");
epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
close(curfd);
} else if(len > 0) {
printf("read buf = %s\n", buf);
write(curfd, buf, strlen(buf) + 1);
}
}
}
}
close(lfd);
close(epfd);
return 0;
}
注意：有数据epoll只会通知一次；
运行程序：
运行服务端和客户端；
客户端： 输入数据
服务端：
问：为什么这里出现了两次ret=1，两次变化的文件描述符相同吗？（不相同！第一次：服务器监听的文件描述符检测到了有新连接进来了，因此内核就将这个文件描述符放到epoll实例的双向链表中去；第二次：因为有新的连接进来了，内核会将这个连接的文件描述符也放到红黑树中去检测，客户端有数据发送过来，内核将这个连接文件描述符放到双向链表中；）
只收到了设置缓冲区大小的数据，hello；有数据的话，第一次会通知你，数据没有读完，就会进入下一次epoll_wait()中检测，阻塞在epoll_wait()处，此时如果文件描述符缓冲区中数据没有发生变化，不会再通知你了。
此时，客户端再想文件描述符缓冲区中写入数据：hhhhhh
此时服务端又会打印5个字符：nihao；因为缓冲区的限制，一次只能读5个数据；
接着发数据：依然是每发一次数据，就会打印5个字符；
注意： ret=1，是客户端和服务端连接的那个文件描述符发生变化了。
因此，我们在后面需要重新写代码，将数据一次性全部读出来。
修改后的ET模式代码：
#include <stdio.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <errno.h>
int main() {
// 创建socket
int lfd = socket(PF_INET, SOCK_STREAM, 0);
struct sockaddr_in saddr;
saddr.sin_port = htons(9999);
saddr.sin_family = AF_INET;
saddr.sin_addr.s_addr = INADDR_ANY;
// 绑定
bind(lfd, (struct sockaddr *)&saddr, sizeof(saddr));
// 监听
listen(lfd, 8);
// 调用epoll_create()创建一个epoll实例
int epfd = epoll_create(100);
// 将监听的文件描述符相关的检测信息添加到epoll实例中
struct epoll_event epev;
epev.events = EPOLLIN;
epev.data.fd = lfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &epev);
struct epoll_event epevs[1024];
while(1) {
int ret = epoll_wait(epfd, epevs, 1024, -1);
if(ret == -1) {
perror("epoll_wait");
exit(-1);
}
printf("ret = %d\n", ret);
for(int i = 0; i < ret; i++) {
int curfd = epevs[i].data.fd;
if(curfd == lfd) {
// 监听的文件描述符有数据达到，有客户端连接
struct sockaddr_in cliaddr;
int len = sizeof(cliaddr);
int cfd = accept(lfd, (struct sockaddr *)&cliaddr, &len);
// 设置连接的文件描述符—cfd属性非阻塞
int flag = fcntl(cfd, F_GETFL);
flag |= O_NONBLOCK; --设置非阻塞
fcntl(cfd, F_SETFL, flag); --再将文件买舒服权限设置回去
epev.events = EPOLLIN | EPOLLET; // 设置边沿触发
epev.data.fd = cfd;
epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &epev);
} else {
if(epevs[i].events & EPOLLOUT) {
continue;
}
// 循环读取出所有数据
char buf[5];
int len = 0;
while( (len = read(curfd, buf, sizeof(buf))) > 0) {
// 打印数据
// printf("recv data : %s\n", buf);
write(STDOUT_FILENO, buf, len); --通过write直接写到终端
write(curfd, buf, len); --回写给客户端
}
if(len == 0) {
printf("client closed....");
}else if(len == -1) { //没有数据和错误都会返回-1;
if(errno == EAGAIN) { --数据完毕会返回EAGAIN信号
printf("data over.....");
}else {
perror("read");
exit(-1);
}
}
}
}
}
close(lfd);
close(epfd);
return 0;
}
运行程序：
运行客户端，服务端；
客户端： 输入数据；
服务端： 此时将数据全部拿到了。
注意：在len==-1的情况下，可能会出现一种错误：
else if(len == -1) {
if(errno == EAGAIN) {
printf("data over.....");
}else {
perror("read");
exit(-1);
}
EINTR： 如果read函数在阻塞时，被一个信号中断了，回来之后就不会阻塞了，回来之后就报错EINTR.
EAGAIN： 在read函数的返回值为-1的情况下：如果socket为非阻塞，缓冲区没有数据了，可能会出这种错，就是数据已经读完了，还通过非阻塞的方式进行读，需要进行判断处理下（只会在非阻塞的情况下才会产生）。
4123
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
