本文深入探讨了Linux下的Epoll机制，对比select函数的局限性，Epoll提供了更高效的并发处理能力，适合现代Web服务器开发。文章详细介绍了Epoll的三个核心函数：epoll_create、epoll_ctl和epoll_wait，并通过示例代码展示了Epoll服务器和客户端的具体实现过程。
epoll方式只在Linux下提供支持
回顾一下之前说过select函数：
select函数不适用于以web服务器端开发为主流的现代开发环境
select复用方法，无法同时接入上百个客户端select函数每次需要复制并保存原有信息，
传递监视对象信息，向操作系统传递数据【对程序造成很大负担，无法从优化代码解决】
套接字是由操作体统管理的
但是，select函数支持大多数操作系统，这是epoll不具备的
弥补select函数缺点：仅向操作体统传递1次监视对象，监视范围或内容发生变化时只通知发生变化的项
但前提是操作系统支持这种方式，Linux是epoll，Windows是IOCP
epoll的优点
无需编写以监视状态变化为目的的针对所有文件描述符的循环语句
调用对应于select函数的epoll_wait函数时无需每次传递监视对象信息
select和epoll的主要差异
1、select方式声明fd_set变量保存监视对象文件描述符，epoll方式由操作系统负责保存监视对象文件描述符
因此需要用epoll_create向操作系统请求创建保存文件描述符的空间
2、为了添加和删除监视对象文件描述符，select方式中需要FD_SET、FD_CLR函数，
epoll中，通过epoll_ctl函数请求操作系统完成
3、select方式调用select函数等待文件描述符变化，epoll中调用epoll_wait函数
4、select中通过fd_set变量查看监视对象的状态变化，epoll通过结构体epoll_event将发生变化的文件描述符单独集中到一起
struct epoll_event
{
__uint32_t events;
epoll_data_t data;
}
typedef union epoll_data
{
void * ptr;
int fd;
__uint32_t u32;
__uint64_t u64;
} epoll_data_t;
声明足够大的epoll_event数组后，传递给epoll_wait函数时，发生变化的文件描述符信息被填入该数组
因此，不需要像select函数那样针对所有文件描述符继续循环
下面详细介绍epoll：
三个函数：
epoll_create：创建保存epoll文件描述符的空间【向操作系统请求】
epoll_ctl：向空间注册/注销文件描述符
epoll_wait：等待文件描述符变化【三个函数中默认最后调用】
epoll_create
#include <sys/epoll.h>
int epoll_create(int size);
成功时返回epoll文件描述符，失败时返回-1
size，向操作系统建议的epoll例程大小，Linux2.6.8之后的内核忽略此参数，自动匹配例程大小
epoll_create函数创建的资源与套接字相同，由操作系统管理，该函数会返回文件描述符，终止时调用close
epoll_ctl
#include <sys/epoll.h>
int epoll_ctl(int epfd, int op, int fd, struct epoll_event * event);
成功返回0，失败-1
epfd 用于注册监视对象的epoll例程的文件描述符
op 用于指定监视对象的添加、删除或更改等操作 EPOLL_CTL_ADD【增加】，EPOLL_CTL_DEL【删除】，EPOLL_CTL_MOD【更改】
fd 需要注册的监视对象文件描述符
event 监视对象的事件类型，通常是结构体，可以保存多种常量，如EPOLLIN【需要读取数据的情况】，可以通过位或运算同时传递多个参数
例：epoll_ctl（A， EPOLL_CTL_ADD, B, C);
epoll例程A中注册文件描述符B，主要目的是监测参数C中的事件
从监视对象中删除文件描述符时，不需要监视类型
epoll_wait
#include <sys/epoll.h>
int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
成功时返回发生事件的文件描述符数，失败时返回-1
epfd 表示事件发生监视范围的epoll例程的文件描述符
events 保存发生事件的文件描述符集合的结构体地址值
maxevents 第二个参数中可以保存的最大事件数
timeout 以千分之一秒为单位的等待时间，传递-1时，一直等待到发生事件
无法针对所有文件描述符循环
再补充一点相关知识：
条件触发：只要输入缓冲有数据就会一直通知该事件
边缘触发：输入缓冲收到数据时仅注册一次该事件，一次读取输入缓冲所有数据
epoll默认以条件触发方式工作，select函数默认以条件触发方式工作
边缘触发：
通过errno【Linux的全局变量，访问该变量需要引入error.h头文件】验证错误原因
为了完成非阻塞I/O. 更改套接字特性
每种函数发生错误时，保存在errno变量中的值都不同，read函数发现输入缓冲中
没有可读数据时返回-1，同时在errno函数中保存常量EAGAIN
将套接字改为非阻塞模式的函数
#include <fcntl.h>
int fcntl(int filedes, int cmd, ...);
成功返回cmd参数相关值，失败返回-1
filedes 属性更改目标的文件描述符
cmd 表示函数调用的目的
向第二个参数传递F_GETFL，获得第一个参数所指文件描述符属性（int型）
传递F_SETFL，更改文件描述符属性
将文件描述符设置为非阻塞模式
int flag = fcntl(fd, F_GETFL, 0); 获取之前设置的属性信息
fcntl(fd, F_SETFL, flag|O_NONBLOCK); 在此基础上添加非阻塞
边缘触发优点：
分离接收数据和处理数据的时间点
直接上代码：
epoll服务器：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#define BUF_SIZE 100
#define EPOLL_SIZE 50
void error_handling(char *buf);
int main(int argc, char *argv[])
{
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
socklen_t adr_sz;
int str_len, i;
char buf[BUF_SIZE];
struct epoll_event *ep_events;
struct epoll_event event;
int epfd, event_cnt;
if(argc!=2) {
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
serv_sock=socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family=AF_INET;
serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_adr.sin_port=htons(atoi(argv[1]));
if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
error_handling("bind() error");
if(listen(serv_sock, 5)==-1)
error_handling("listen() error");
epfd=epoll_create(EPOLL_SIZE);
ep_events=malloc(sizeof(struct epoll_event)*EPOLL_SIZE);
event.events=EPOLLIN;
event.data.fd=serv_sock;
epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);
while(1)
{
event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);
if(event_cnt==-1)
{
puts("epoll_wait() error");
break;
}
for(i=0; i<event_cnt; i++)
{
if(ep_events[i].data.fd==serv_sock)
{
adr_sz=sizeof(clnt_adr);
clnt_sock=
accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
event.events=EPOLLIN;
event.data.fd=clnt_sock;
epoll_ctl(epfd, EPOLL_CTL_ADD, clnt_sock, &event);
printf("connected client: %d \n", clnt_sock);
}
else
{
str_len=read(ep_events[i].data.fd, buf, BUF_SIZE);
if(str_len==0) // close request!
{
epoll_ctl(
epfd, EPOLL_CTL_DEL, ep_events[i].data.fd, NULL);
close(ep_events[i].data.fd);
printf("closed client: %d \n", ep_events[i].data.fd);
}
else
{
write(ep_events[i].data.fd, buf, str_len); // echo!
}
}
}
}
close(serv_sock);
close(epfd);
return 0;
}
void error_handling(char *buf)
{
fputs(buf, stderr);
fputc('\n', stderr);
exit(1);
}
epoll客户端：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#define BUF_SIZE 1024
void error_handling(char *message);
int main(int argc, char *argv[])
{
int sock;
char message[BUF_SIZE];
int str_len;
struct sockaddr_in serv_adr;
if(argc!=3) {
printf("Usage : %s <IP> <port>\n", argv[0]);
exit(1);
}
sock=socket(PF_INET, SOCK_STREAM, 0);
if(sock==-1)
error_handling("socket() error");
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family=AF_INET;
serv_adr.sin_addr.s_addr=inet_addr(argv[1]);
serv_adr.sin_port=htons(atoi(argv[2]));
if(connect(sock, (struct sockaddr*)&serv_adr, sizeof(serv_adr))==-1)
error_handling("connect() error!");
else
puts("Connected...........");
while(1)
{
fputs("Input message(Q to quit): ", stdout);
fgets(message, BUF_SIZE, stdin);
if(!strcmp(message,"q\n") || !strcmp(message,"Q\n"))
break;
write(sock, message, strlen(message));
str_len=read(sock, message, BUF_SIZE-1);
message[str_len]=0;
printf("Message from server: %s", message);
}
close(sock);
return 0;
}
void error_handling(char *message)
{
fputs(message, stderr);
fputc('\n', stderr);
exit(1);
}条件触发
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#define BUF_SIZE 4
#define EPOLL_SIZE 50
void error_handling(char *buf);
int main(int argc, char *argv[])
{
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
socklen_t adr_sz;
int str_len, i;
char buf[BUF_SIZE];
struct epoll_event *ep_events;
struct epoll_event event;
int epfd, event_cnt;
if(argc!=2) {
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
serv_sock=socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family=AF_INET;
serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_adr.sin_port=htons(atoi(argv[1]));
if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
error_handling("bind() error");
if(listen(serv_sock, 5)==-1)
error_handling("listen() error");
epfd=epoll_create(EPOLL_SIZE);
ep_events=malloc(sizeof(struct epoll_event)*EPOLL_SIZE);
event.events=EPOLLIN;
event.data.fd=serv_sock;
epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);
while(1)
{
event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);
if(event_cnt==-1)
{
puts("epoll_wait() error");
break;
}
puts("return epoll_wait");
for(i=0; i<event_cnt; i++)
{
if(ep_events[i].data.fd==serv_sock)
{
adr_sz=sizeof(clnt_adr);
clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
event.events=EPOLLIN;
event.data.fd=clnt_sock;
epoll_ctl(epfd, EPOLL_CTL_ADD, clnt_sock, &event);
printf("connected client: %d \n", clnt_sock);
}
else
{
str_len=read(ep_events[i].data.fd, buf, BUF_SIZE);
if(str_len==0) // close request!
{
epoll_ctl(epfd, EPOLL_CTL_DEL, ep_events[i].data.fd, NULL);
close(ep_events[i].data.fd);
printf("closed client: %d \n", ep_events[i].data.fd);
}
else
{
write(ep_events[i].data.fd, buf, str_len); // echo!
}
}
}
}
close(serv_sock);
close(epfd);
return 0;
}
void error_handling(char *buf)
{
fputs(buf, stderr);
fputc('\n', stderr);
exit(1);
}边缘触发：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <errno.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/epoll.h>
#define BUF_SIZE 4
#define EPOLL_SIZE 50
void setnonblockingmode(int fd);
void error_handling(char *buf);
int main(int argc, char *argv[])
{
int serv_sock, clnt_sock;
struct sockaddr_in serv_adr, clnt_adr;
socklen_t adr_sz;
int str_len, i;
char buf[BUF_SIZE];
struct epoll_event *ep_events;
struct epoll_event event;
int epfd, event_cnt;
if(argc!=2) {
printf("Usage : %s <port>\n", argv[0]);
exit(1);
}
serv_sock=socket(PF_INET, SOCK_STREAM, 0);
memset(&serv_adr, 0, sizeof(serv_adr));
serv_adr.sin_family=AF_INET;
serv_adr.sin_addr.s_addr=htonl(INADDR_ANY);
serv_adr.sin_port=htons(atoi(argv[1]));
if(bind(serv_sock, (struct sockaddr*) &serv_adr, sizeof(serv_adr))==-1)
error_handling("bind() error");
if(listen(serv_sock, 5)==-1)
error_handling("listen() error");
epfd=epoll_create(EPOLL_SIZE);
ep_events=malloc(sizeof(struct epoll_event)*EPOLL_SIZE);
setnonblockingmode(serv_sock);
event.events=EPOLLIN;
event.data.fd=serv_sock;
epoll_ctl(epfd, EPOLL_CTL_ADD, serv_sock, &event);
while(1)
{
event_cnt=epoll_wait(epfd, ep_events, EPOLL_SIZE, -1);
if(event_cnt==-1)
{
puts("epoll_wait() error");
break;
}
puts("return epoll_wait");
for(i=0; i<event_cnt; i++)
{
if(ep_events[i].data.fd==serv_sock)
{
adr_sz=sizeof(clnt_adr);
clnt_sock=accept(serv_sock, (struct sockaddr*)&clnt_adr, &adr_sz);
setnonblockingmode(clnt_sock);
event.events=EPOLLIN|EPOLLET;
event.data.fd=clnt_sock;
epoll_ctl(epfd, EPOLL_CTL_ADD, clnt_sock, &event);
printf("connected client: %d \n", clnt_sock);
}
else
{
while(1)
{
str_len=read(ep_events[i].data.fd, buf, BUF_SIZE);
if(str_len==0) // close request!
{
epoll_ctl(epfd, EPOLL_CTL_DEL, ep_events[i].data.fd, NULL);
close(ep_events[i].data.fd);
printf("closed client: %d \n", ep_events[i].data.fd);
break;
}
else if(str_len<0)
{
if(errno==EAGAIN)
break;
}
else
{
write(ep_events[i].data.fd, buf, str_len); // echo!
}
}
}
}
}
close(serv_sock);
close(epfd);
return 0;
}
void setnonblockingmode(int fd)
{
int flag=fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flag|O_NONBLOCK);
}
void error_handling(char *buf)
{
fputs(buf, stderr);
fputc('\n', stderr);
exit(1);
}
扫一扫
736
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
