EPOLL事件有两种模型:
Edge Triggered (ET) 边缘触发只有数据到来才触发,不管缓存区中是否还有数据。
Level Triggered (LT) 水平触发只要有数据都会触发。
LT(level triggered):LT是缺省的工作方式,并且同时支持block和no-block socket。在这种做法中,内核告诉你一个文件描述符是否就绪了,然后你可以对这个就绪的fd进行IO操作。如果你不作任何操作,内核还是会继续通知你的。所以,这种模式编程出错误可能性要小一点。传统的select/poll都是这种模型的代表。所以可以不用while循环一次性读完,因为epoll_wait(),内核还会通知你的。
ET(edge-triggered):ET是高速工作方式,只支持no-block socket。在这种模式下,当描述符从未就绪变为就绪时,内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪,并且不会再为那个文件描述符发送更多的就绪通知。请注意,如果一直不对这个fd作IO操作(从而导致它再次变成未就绪),内核不会发送更多的通知(only once)。所以如果使用ET且缓冲区内容不能一次性读完,需要写一个循环将内容全部读取,且需要将套接字的文件描述符设置为非阻塞。
#include
#include
#include
#include
#include
#define MAXLINE 10
int main(int argc, char *argv[])
{
int efd, i;
int pfd[2];
pid_t pid;
char buf[MAXLINE], ch = 'a';
pipe(pfd);
pid = fork();
if (pid == 0) { //子 写
close(pfd[0]);
int count = 2;
while (count--) {
//aaaa\n
for (i = 0; i < MAXLINE/2; i++)
buf[i] = ch;
buf[i-1] = '\n';
ch++;
//bbbb\n
for (; i < MAXLINE; i++)
buf[i] = ch;
buf[i-1] = '\n';
ch++;
//aaaa\nbbbb\n
write(pfd[1], buf, sizeof(buf));
sleep(5);
}
close(pfd[1]);
} else if (pid > 0) { //父 读
struct epoll_event event;
struct epoll_event resevent[10]; //epoll_wait就绪返回event
int res, len;
close(pfd[1]);
efd = epoll_create(10);
// event.events = EPOLLIN | EPOLLET; // ET 边沿触发
event.events = EPOLLIN; // LT 水平触发 (默认)
event.data.fd = pfd[0];
epoll_ctl(efd, EPOLL_CTL_ADD, pfd[0], &event);
while (1) {
res = epoll_wait(efd, resevent, 10, -1);
printf("res %d\n", res);
if (resevent[0].data.fd == pfd[0]) {
len = read(pfd[0], buf, MAXLINE/2);
write(STDOUT_FILENO, buf, len);
}
}
close(pfd[0]);
close(efd);
} else {
perror("fork");
exit(-1);
}
return 0;
}
代码讲解:
count = 2;
理论上说:子进程只会发送两组数据,第一次发“aaaa\nbbbb\n” ,第二次 在5s后,发“cccc\ndddd\n”。
父进程阻塞等待,一次接收5个字节。
// event.events = EPOLLIN | EPOLLET; // ET 边沿触发
event.events = EPOLLIN; // LT 水平触发 (默认)
(LT) 水平触发只要有数据都会触发。所以,父进程进程,几乎是在瞬间就读取了“aaaa\n” 和 “bbbb\n”;然后在5s后几乎在瞬间读取了“cccc\n” 和 “dddd\n”。
5s后,子进程关闭,关闭了管道的写端 pfd[0]。但由于是LT的工作方式,内核还是会告诉你 pfd[0] 已经准备就绪了,你可以对它进行读操作。但由于管道中没有数据,只能读出空。
即使你不作任何操作,内核还是会继续通知你的。
event.events = EPOLLIN | EPOLLET; // ET 边沿触发
// event.events = EPOLLIN; // LT 水平触发 (默认)
(ET) 边缘触发只有数据到来才触发,不管缓存区中是否还有数据。
第一次子进程发 “aaaa\nbbbb\n” 时,父进程只读到了“aaaa\n”。管道里残留着“bbbb\n”。
第二次进程发 “cccc\ndddd\n” 时,属于边沿触发,父进程只读到了上次管道里残留着的 “bbbb\n”。
子进程发了两次后,关闭官道的写端。这时,个人猜测:又属于一次边沿触发,父进程读到了“cccc\n” 。然后由于子进程 不再提供边沿触发信号,父进程会一直卡住,永远没机会读到管道里的残留着的“dddd\n”。
补充:本人测了管道的文件描述符,发现默认是阻塞的。
flag = fcntl(connfd, F_GETFL); /* 修改connfd为非阻塞读 */
flag |= O_NONBLOCK;
fcntl(connfd, F_SETFL, flag);
例:
epoll 的 ET模式, 高效模式,但是只支持 非阻塞模式。 --- 忙轮询。
struct epoll_event event;
event.events = EPOLLIN | EPOLLET; //监听EPOLLIN事件; 设置为边缘触发,内核只提示一次,要尽可能一次读完。
int flag = fcntl(cfd, F_GETFL);
flag |= O_NONBLOCK;
fcntl(cfd, F_SETFL, flag);
epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &event);
使用ET设置为边缘触发,内核只提示一次,要尽可能一次读完。所以如果缓冲区内容不能一次性读完,需要写一个循环将内容全部读取,且需要将套接字的文件描述符设置为非阻塞。
本人测了管道的文件描述符,发现默认是阻塞的。因为buf.szie() = 5, read()函数一次只能读5个字节。epoll监听cfd的 EPOLLIN | EPOLLET事件,内核只提醒一次。如果read()函数一次读不完,又没有下一批数据到来(无法边缘触发),还使用while函数的话,程序将阻塞在read()函数,无法继续执行。正确做法是:还需要将cfd设置为非阻塞,用while循环持续读。
// 设置cfd属性非阻塞
int flag = fcntl(cfd, F_GETFL);
flag |= O_NONBLOCK;
fcntl(cfd, F_SETFL, flag);
平时read函数读阻塞的文件描述符时,返回了-1,代表发生错误。但,因为套接字的文件描述符被设置为非阻塞,flag |= O_NONBLOCK ; 所以当非阻塞读数据,没有读到数据,返回了-1时,不能单纯的将它作为错误处理,而要继续判断errno的值。如果返回值为-1,且errno = EAGAIN,那么代表这批数据已经读完了。EAGAIN代表:错误,再读一次。这次没数据,下一次可能还会给你发数据。
while( (len = read(curfd, buf, sizeof(buf))) > 0) { //非阻塞不断地读数据
// 打印数据
// printf("recv data : %s\n", buf);
write(STDOUT_FILENO, buf, len);
write(curfd, buf, len);
}
if(len == 0) { // 对方断开连接,没有数据可读了。
printf("client closed....");
}else if(len == -1) { //非阻塞读数据,把数据读完了,返回了-1.
if(errno == EAGAIN) {
printf("data over.....");
}else {
perror("read");
exit(-1);
}
}
EAGAIN or EWOULDBLOCK
The file is a socket, the O_NONBLOCK flag is set for the file descriptor, and the thread would be delayed in the read operation.
文件是一个套接字,为文件描述符设置了O_NONBLOCK标志,线程在读操作中会被延迟。
EAGAIN:(error, again read one----->错误,再读一次)
The file is neither a pipe, nor a FIFO, nor a socket, the O_NONBLOCK flag is set for the file descriptor, and the thread would be delayed in the read operation.
EAGAIN 文件既不是管道,也不是 FIFO,也不是套接字,文件描述符设置了 O_NONBLOCK 标志,线程在读操作中会被延迟。
#include
#include
#include
#include
#include
#include
#include
#include
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(curfd, buf, len);
}
if(len == 0) {
printf("client closed....");
}else if(len == -1) {
if(errno == EAGAIN) {
printf("data over.....");
}else {
perror("read");
exit(-1);
}
}
}
}
}
close(lfd);
close(epfd);
return 0;
}