【Linux】ET和LT模式总结

总结

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且缓冲区内容不能一次性读完，需要写一个循环将内容全部读取，且需要将套接字的文件描述符设置为非阻塞。

---

ET和LT模式的区别

#include <stdio.h>
#include <stdlib.h>
#include <sys/epoll.h>
#include <errno.h>
#include <unistd.h>

#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设置为边缘触发，内核只提示一次，要尽可能一次读完。所以如果缓冲区内容不能一次性读完，需要写一个循环将内容全部读取，且需要将套接字的文件描述符设置为非阻塞。

---

问题分析与总结 

ET是高速工作方式，只支持no-block socket：

本人测了管道的文件描述符，发现默认是阻塞的。因为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);

不能将errno = EAGAIN视为错误：

平时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 <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(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;
}