4.31、epoll的两种工作模式

1.Epoll的工作模式

①LT模式（水平触发）

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

• a: 用户不读数据，数据一直在缓冲区，epoll 会一直通知。
• b: 用户只读了一部分数据，epoll会通知
• c: 缓冲区的数据读完了，不通知

struct epoll_event {
	uint32_t events; /* Epoll events */
	epoll_data_t data; /* User data variable */
};
常见的Epoll检测事件：
	- EPOLLIN
	- EPOLLOUT
	- EPOLLERR
	- EPOLLET

epoll的正常情况下就是LT模式（代码实现）

#include 
#include 
#include 
#include 
#include 

using namespace std;

int main() {

    // 创建监听用的文件描述符
    int server_listen_fd = socket(PF_INET, SOCK_STREAM, 0);


    // 绑定服务器的端口和ip地址
    sockaddr_in server_addr;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(9999);

    bind(server_listen_fd, (sockaddr *)&server_addr, sizeof(server_addr));


    // 监听客户端的连接数据
    listen(server_listen_fd, 8);

    // 创建epoll的实例，是一颗红黑树（有一个就绪状态时双向链表）
    int epoll_fd = epoll_create(2);
    // 将监听描述符加入到epoll的红黑树结构中
    epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = server_listen_fd;
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_listen_fd, &event);

    // 创建一个epoll_wait的传出参数，是一个数组类型
    epoll_event events[1024];
    int events_len = 1;

    while (1) {

        // 监听红黑树中的结构什么发生变化
        int change_len = epoll_wait(epoll_fd, events, events_len, -1);

        if (change_len == -1) {
            perror("epoll_wait");
            exit(-1);
        } else if (change_len == 0) {
            // 只有不阻塞的情况下出现
            continue;
        } else if (change_len > 0) {
            
            cout << "epoll wait ret: " << change_len << endl;

            for (int i = 0; i < change_len; i ++ ) {

                if (events[i].data.fd == server_listen_fd) {
                    
                    // 定义客户端的传出参数
                    sockaddr_in client_addr;
                    socklen_t client_addr_len = sizeof(client_addr);
                    int client_fd = accept(server_listen_fd, (sockaddr *)&client_addr, &client_addr_len);

                    // 将新加入的客户端文件描述符加入到我们的红黑树结构中
                    event.events = EPOLLIN;
                    event.data.fd = client_fd;
                    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event);
                    // 数组的有效长度 + 1
                    events_len ++ ;

                } else if ((events[i].events & EPOLLIN) == EPOLLIN) {

                    // 发现有客户端通信之间的读的文件描述符之间发生变化
                    char buf[1024];
                    int recv_ret = recv(events[i].data.fd, buf, sizeof(buf), 0);

                    if (recv_ret == -1) {
                        perror("recv");
                        exit(-1);
                    } else if (recv_ret == 0) {
                        cout << "clinet closed..." << endl;
                        // 将断开的客户端从我们的红黑树中删掉
                        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
                        // 关闭文件描述符
                        close(events[i].data.fd);
                        // 将我们的有效长度减1
                        events_len -- ;
                    } else if (recv_ret > 0) {

                        // 输出读取到的信息
                        printf("I am server, data: %s\n", buf);

                        // 将数据反返回给客户端
                        send(events[i].data.fd, buf, strlen(buf) + 1, 0);

                    }

                }

            }

        }

    }


    close(epoll_fd);
    close(server_listen_fd);
    return 0;
}

②ET模式（边沿触发）

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

• a: 用户不读数据，数据一致在缓冲区中，epoll下次检测的时候就不通知了
• b: 用户只读了一部分数据，epoll不通知
• c: 缓冲区的数据读完了，不通知

ET模式下要注意设置非阻塞（代码实现）

#include 
#include 
#include 
#include 
#include 
#include 
#include 

using namespace std;

int main() {

    // 创建监听用的文件描述符
    int server_listen_fd = socket(PF_INET, SOCK_STREAM, 0);


    // 绑定服务器的端口和ip地址
    sockaddr_in server_addr;
    server_addr.sin_addr.s_addr = INADDR_ANY;
    server_addr.sin_family = AF_INET;
    server_addr.sin_port = htons(9999);

    bind(server_listen_fd, (sockaddr *)&server_addr, sizeof(server_addr));


    // 监听客户端的连接数据
    listen(server_listen_fd, 8);

    // 创建epoll的实例，是一颗红黑树（有一个就绪状态时双向链表）
    int epoll_fd = epoll_create(2);
    // 将监听描述符加入到epoll的红黑树结构中
    epoll_event event;
    event.events = EPOLLIN;
    event.data.fd = server_listen_fd;
    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, server_listen_fd, &event);

    // 创建一个epoll_wait的传出参数，是一个数组类型
    epoll_event events[1024];
    int events_len = 1;

    while (1) {

        // 监听红黑树中的结构什么发生变化
        int change_len = epoll_wait(epoll_fd, events, events_len, -1);

        if (change_len == -1) {
            perror("epoll_wait");
            exit(-1);
        } else if (change_len == 0) {
            // 只有不阻塞的情况下出现
            continue;
        } else if (change_len > 0) {
            
            cout << "epoll wait ret: " << change_len << endl;

            for (int i = 0; i < change_len; i ++ ) {

                if (events[i].data.fd == server_listen_fd) {
                    
                    // 定义客户端的传出参数
                    sockaddr_in client_addr;
                    socklen_t client_addr_len = sizeof(client_addr);
                    int client_fd = accept(server_listen_fd, (sockaddr *)&client_addr, &client_addr_len);

                    // 将新加入的客户端文件描述符加入到我们的红黑树结构中
                    event.events = EPOLLIN | EPOLLET;

                    // 设置读数据的时候非阻塞
                    int flag = fcntl(client_fd, F_GETFL);
                    flag |= O_NONBLOCK;
                    fcntl(client_fd, F_SETFL, flag);

                    event.data.fd = client_fd;
                    epoll_ctl(epoll_fd, EPOLL_CTL_ADD, client_fd, &event);
                    // 数组的有效长度 + 1
                    events_len ++ ;

                } else if ((events[i].events & EPOLLIN) == EPOLLIN) {

                    // 发现有客户端通信之间的读的文件描述符之间发生变化
                    char buf[5];
                    int len = 0;
                    while ((len = read(events[i].data.fd, buf, sizeof(buf))) > 0) {
                        // cout << "read: " << buf << endl;
                        write(STDOUT_FILENO, buf, len);
                        write(events[i].data.fd, buf, len);
                    }

                    if (len == 0) {
                        // 非阻塞的情况下返回0时读取完毕
                        cout << "client closed..." << endl;
                        epoll_ctl(epoll_fd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
                        close(events[i].data.fd);
                        events_len -- ;

                    } else if (len == -1) {
                        
                        if (errno == EAGAIN || errno == EWOULDBLOCK) {
                            ///如果是对方关闭连接
                            cout << "data over ..." << endl;
                        } else {
                            // 错误
                            perror("read");
                            exit(-1);
                        }

                    }


                }

            }

        }

    }


    close(epoll_fd);
    close(server_listen_fd);
    return 0;
}