epoll() 多路复用 和 两种工作模式

呵呵哒(￣▽￣)"2023-08-28 8:56

1.epoll API 介绍

cpp 复制代码 
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 */
};

常见的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 : 检测文件描述符什么事情

// 检测函数----检测epoll树中是否有就绪的文件描述符
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout);
	- 参数：
		- epfd : epoll实例对应的文件描述符
		- events : 传出参数，保存了发送了变化的文件描述符的信息
		- maxevents : 第二个参数结构体数组的大小
		- timeout : 阻塞时间
			- 0 : 不阻塞
			- -1 : 阻塞，直到检测到fd数据发生变化，解除阻塞
			- > 0 : 阻塞的时长（毫秒）
	- 返回值：
		- 成功，返回发送变化的文件描述符的个数 > 0
		- 失败 -1

// 创建epoll实例，通过一棵红黑树管理待检测集合
int epoll_create(int size);
cpp 复制代码 
// epoll 的使用
// 操作步骤
// 在服务器使用 epoll 进行 IO 多路转接的操作步骤如下:
    1.创建监听的套接字
    int lfd = socket(AF_INET, SOCK_STREAM, 0);

    2.设置端口复用（可选）
    int opt = 1;
    setsockopt(lfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt));

    3.使用本地的IP与端口和监听的套接字进行绑定
    int ret = bind(lfd, (struct sockaddr*)&saddr, sizeof(saddr));

    4.给监听的套接字设置监听
    listen(lfd, 128);

    5.创建 epoll 实例
    int epfd = epoll_create(100);

    6.将用于监听的套接字添加到 epoll 实例中
    struct epoll_event ev;
    ev.events = EPOLLIN; //检测lfd读缓冲区是否有数据
    ev.data.fd = lfd;
    int ret = epoll_ctl(epfd, EPOLL_CTL_ADD, lfd, &ev);

    接着创建一个数组，用于存储epoll_wait()返回的文件描述符
    struct epoll_event evs[1024];

    7.检测添加到epoll实例中的文件描述符是否已经就绪，并将这些已就绪的文件描述符进行处理
    int num = epoll_wait(epfd, evs, size, -1);

    ① 如果监听的是文件描述符，和新客户端建立连接，将得到的文件描述符添加到epoll实例中
    int cfd = accept(curfd,NULL,NULL);
    ev.events = EPOLLIN;
    ev.data.fd = cfd;

    新得到的文件描述符添加到epoll模型中，下一轮循环的时候就可以被检测了
    epoll_ctl(epfd, EPOLL_CTL_ADD, cfd, &ev);

    ② 如果是通信的文件描述符，和对应的客户端通信，如果连接已断开，将该文件描述符从epoll实例中删除
    int len = recv(curfd,buf,sizeof(buf),0);
    if(len == 0) {
        // 将这个文件描述符从epoll实例中删除
        epoll_ctl(epfd, EPOLL_CTL_DEL, curfd, NULL);
        close(curfd);
    }else if(len > 0) {
        send(curfd,buf,len,0);
    }

    8.重复第 7 步的操作

server.c

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/epoll.h>

int main() {
    
    // 创建socket
    int lfd = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    saddr.sin_addr.s_addr = INADDR_ANY;

    // 绑定
    int ret = bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if(ret == -1) {
        perror("bind");
        exit(-1);
    }

    // 监听
    ret = listen(lfd,8);
    if(ret == -1) {
        perror("listen");
        exit(-1);
    }

    // 用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);

    // 创建一个数组，用于存储epoll_wait()返回的文件描述符
    struct epoll_event epevs[1024];
    while (1) {
        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 caddr;
                int len = sizeof(caddr);
                int cfd = accept(lfd,(struct sockaddr*)&caddr,&len);

                // epev.events = EPOLLIN | EPOLLOUT;
                epev.events = EPOLLIN;
                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);
                    close(curfd);
                } else if(len > 0) {
                    printf("recv buf = %s\n",buf);
                    write(curfd,buf,strlen(buf) + 1);
                }
            }
        }
    }
    close(lfd);
    close(epfd);
    return 0;
}

client.c

cpp 复制代码 
#include <stdio.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int main(int argc,char* argv[]) {
    int fd = socket(AF_INET,SOCK_STREAM,0);
    if(fd == -1) {
        perror("socket");
        return -1;
    }

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    inet_pton(AF_INET,"127.0.0.1",&saddr.sin_addr.s_addr);

    // 连接服务器
    int ret = connect(fd,(struct sockaddr*)&saddr,sizeof(saddr));

    if(ret == -1) {
        perror("connect");
        return -1;
    }

    int num = 0;
    while (1) {
        char sendBuf[1024] = {0};
        sprintf(sendBuf,"send data %d",num++);
        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;
        }
        // sleep(1);
        usleep(1000);
    }
    
    close(fd);
    return 0;
}

2.epoll 的两种工作模式

cpp 复制代码 
Epoll 的工作模式：
	LT 模式 （水平触发）
		假设委托内核检测读事件 -> 检测fd的读缓冲区
			读缓冲区有数据 - > epoll检测到了会给用户通知
				a.用户不读数据，数据一直在缓冲区，epoll 会一直通知
				b.用户只读了一部分数据，epoll会通知
				c.缓冲区的数据读完了，不通知
	
	LT（level - triggered）是缺省的工作方式，并且同时支持 block 和 no-block socket。在这
	种做法中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的 fd 进行 IO 操
	作。如果你不作任何操作，内核还是会继续通知你的。

	ET 模式（边沿触发）
		假设委托内核检测读事件 -> 检测fd的读缓冲区
			读缓冲区有数据 - > epoll检测到了会给用户通知
				a.用户不读数据，数据一直在缓冲区中，epoll下次检测的时候就不通知了
				b.用户只读了一部分数据，epoll不通知
				c.缓冲区的数据读完了，不通知

	ET（edge - triggered）是高速工作方式，只支持 no-block socket。在这种模式下，当描述
	符从未就绪变为就绪时，内核通过epoll告诉你。然后它会假设你知道文件描述符已经就绪，
	并且不会再为那个文件描述符发送更多的就绪通知，直到你做了某些操作导致那个文件描述
	符不再为就绪状态了。但是请注意，如果一直不对这个 fd 作 IO 操作（从而导致它再次变成
	未就绪），内核不会发送更多的通知（only once）。
	
	ET 模式在很大程度上减少了 epoll 事件被重复触发的次数，因此效率要比 LT 模式高。epoll
	工作在 ET 模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写
	操作把处理多个文件描述符的任务饿死。

【注意】 ET模式需要配合循环+非阻塞

（1）LT 模式

epoll_lt.c

cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/epoll.h>

int main() {
    
    // 创建socket
    int lfd = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    saddr.sin_addr.s_addr = INADDR_ANY;

    // 绑定
    int ret = bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if(ret == -1) {
        perror("bind");
        exit(-1);
    }

    // 监听
    ret = listen(lfd,8);
    if(ret == -1) {
        perror("listen");
        exit(-1);
    }

    // 用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);

    // 创建一个数组，用于存储epoll_wait()返回的文件描述符
    struct epoll_event epevs[1024];
    while (1) {
        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 caddr;
                int len = sizeof(caddr);
                int cfd = accept(lfd,(struct sockaddr*)&caddr,&len);

                // epev.events = EPOLLIN | EPOLLOUT;
                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("recv buf = %s\n",buf);
                    write(curfd,buf,strlen(buf) + 1);
                }
            }
        }
    }
    close(lfd);
    close(epfd);
    return 0;
}

（2）ET 模式

cpp 复制代码 
struct epoll_event {
    uint32_t events; /* Epoll events */
    epoll_data_t data; /* User data variable */
};

常见的Epoll检测事件：
    - EPOLLIN
    - EPOLLOUT
    - EPOLLERR
    - EPOLLET
cpp 复制代码 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/types.h>
#include <arpa/inet.h>
#include <sys/epoll.h>
#include <fcntl.h>
#include <errno.h>

int main() {
    
    // 创建socket
    int lfd = socket(AF_INET,SOCK_STREAM,0);
    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    saddr.sin_addr.s_addr = INADDR_ANY;

    // 绑定
    int ret = bind(lfd,(struct sockaddr*)&saddr,sizeof(saddr));
    if(ret == -1) {
        perror("bind");
        exit(-1);
    }

    // 监听
    ret = listen(lfd,8);
    if(ret == -1) {
        perror("listen");
        exit(-1);
    }

    // 用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);

    // 创建一个数组，用于存储epoll_wait()返回的文件描述符
    struct epoll_event epevs[1024];
    while (1) {
        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 caddr;
                int len = sizeof(caddr);
                int cfd = accept(lfd,(struct sockaddr*)&caddr,&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...\n");
                }else if(len == -1) {
                    if(errno == EAGAIN) {
                        printf("data over......\n");
                    } else {
                        perror("read");
                        exit(-1);
                    }
                }
            }
        }
    }
    close(lfd);
    close(epfd);
    return 0;
}

client.c

cpp 复制代码 
#include <stdio.h>
#include <ctype.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>

int main(int argc,char* argv[]) {
    int fd = socket(AF_INET,SOCK_STREAM,0);
    if(fd == -1) {
        perror("socket");
        return -1;
    }

    struct sockaddr_in saddr;
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(9999);
    inet_pton(AF_INET,"127.0.0.1",&saddr.sin_addr.s_addr);

    // 连接服务器
    int ret = connect(fd,(struct sockaddr*)&saddr,sizeof(saddr));

    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;
        }
        // sleep(1);
        // usleep(1000);
    }
    
    close(fd);
    return 0;
}
相关推荐
Winston Wood1 个月前
Android中的epoll机制
android·性能优化·i/o·epoll
小乌龟不会飞1 个月前
高并发服务的核心机制——IO多路转接---＞epoll
linux·epoll·1024程序员节
诡异森林。1 个月前
Linux--多路转接之epoll
linux·运维·数据库·tcp/ip·epoll
帅得不敢出门3 个月前
记录ssl epoll的tcp socket服务端在客户端断开时崩溃的问题
linux·网络·tcp/ip·socket·ssl·epoll·c/c++
我要成为C++领域大神3 个月前
epoll+线程池模型
linux·服务器·c++·高并发·线程池·多线程·epoll
阿猿收手吧！4 个月前
【Linux网络】epoll实现的echo服务器{nocopy类/智能指针/echo服务器}
linux·服务器·网络·epoll
我要成为C++领域大神5 个月前
【高性能服务器】服务器概述
linux·服务器·c语言·ubuntu·操作系统·epoll·多进程
语言专家5 个月前
C++网络编程实践：使用C++11基于epoll技术实现一个超大并发TCP服务器
服务器·网络协议·tcp/ip·c++11·epoll
linux大本营5 个月前
图解通用网络IO底层原理、Socket、epoll、用户态内核态······
linux·网络·select·socket·epoll
一叶知秋yyds5 个月前
epoll 为什么能提高网络性能
linux·网络·epoll·多路io复用
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10ICLR24大模型提示(1/11) | BadChain：大型语言模型的后门思维链提示