多路复用epoll
Posted shubin
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了多路复用epoll相关的知识，希望对你有一定的参考价值。
epoll基本原理
- epoll 相对于 select 与 poll 有较大的不同，主要是针对前面两种多路复用 IO 接口的不足
- 与 select/poll 方案对比
- select 方案使用数组存储文件描述符，最大支持 1024
- select 每次调用都需要将描述符集合拷贝到内核中,非常消耗资源
- poll 方案解决文件描述符存储数量限制问题，但其他问题没有得到解决
- select / poll 底层使用轮询的方式检测文件描述符是否就绪，文件描述符越多，则效率越低
- epoll 底层使用红黑树，没有文件描述符数量的限制,并且可以动态增加与删除节点，不用重复拷贝
- epoll 底层使用callback 机制,没有采用遍历所有描述符的方式，效率较高
- 与 select/poll 方案对比
- 下面以老师检查学生作业为例，来看两种方案
- select/poll方案
- epoll方案
- select/poll方案
epoll创建
- epoll 创建需要调用 epoll_create 函数,用于创建 epoll 实例
- 函数头文件
- #include <sys/epoll.h>
- 函数原型
- int epoll_create(int size);
- 函数功能
- 创建一个 epoll 实例,分配相关的数据结构空间
- 函数参数
- size: 需要填一个大于0的数，从 Linux 2.6.8 开始，size 参数被忽略
- 函数返回值
- 成功 : 返回 epoll 文件描述符
- 失败: 返回-1,并设置 errno
#include <stdio.h>
#include <stdlib.h>
#include <sys/epoll.h>
int main(void)
int fid = epoll_create(1);
if(fid == -1)
perror("[ERROR] epoll_create();");
exit(EXIT_FAILURE);
printf("%d\\n",fid);
return 0;
高级I/O---多路复用---epoll
多路复用之epoll
作为多路复用中最高效的I/O,epoll有着select和poll都不具有的很多能力。
不同于poll和select，epoll它用三个函数来实现多路复用这一个功能。
#include <sys/epoll.h>
int epoll_create(int size);
//用于创建一个epoll模式的存储空间，返回值是一个文件描述符，后面和函数中
//都会用到这个epoll_fd。
int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
//epoll_ctl用于添加一个事件到epfd中，op表示方式有EPOLL_ADD,EPOLL_DEL
//EPOLL_MOD方式，fd表示你要添加进去的文件描述符，后面是一个结构体指针，
//结构体在下面会说到。
int epoll_wait(int epfd, struct epoll_event *events,int maxevents, int timeout);
//epoll_wait用于等待事件的发生，这个结构体指针会储存返回来的fd，maxevents
//表示最大能够接收到的fd的个数，注意能接收到的fd的个数很多（查阅一些资料这个数据
//在1G内存的机子上大约能有10万余个）。
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 */
};
//这个结构体中包含一个联合体和一个events，events是用来描述触发状态，
//可以设置为EPOLLIN,EPOLLOUT,EPOLLD等。
//联合体中我们关注fd和*ptr因为联合体有时候会有bug产生，如果我们用str来
//存放读取的数据的时候，我们可以让这个ptr指向一个结构体，结构体中设置
//fd和*buf参数。epoll之所以比之前的多路复用高效主要原因有以下几个
1>:epoll的组织方式，它是以两个一个很高效的结构体红黑树，list链表
红黑树用于存放fd,一旦有事件发生它能够以O(1)的时间复杂度找到并且
把它放到list中，这样发回值就是这个event结构体指针，它里面存放的
便是发生事件的fd，从之前多路复用的轮训O(N),减少到O(1)，可见它的
高效之处。
2>:触发方式：epoll可以使用两种触发方式来获取事件；下面会说到的水平
触发和边缘触发。使用边缘触发方式可以使epoll更加高效。
边缘触发和水平触发
水平触发PT：epoll_wait一旦fd中发生状态变化假设状态变化是read，并且如果没有读完，下次会继续提醒，直到把缓冲区fd中的数据读完为止。
边缘触发ET：epoll_wait当fd中状态发生变化时假设状态变化是read,它会在第一次提醒，如果没有把它读完则后面不会再提醒，除非有新的数据到来才会接着上次的往后面读。
在epoll_wait下要将套接字用fcntl函数设置为非阻塞，为什么要设置未非阻塞呢？想了好久的我终于发现，在一次ET中因为并不保证把缓冲区中的数据彻底读完，而阻塞模式下的sock是要保证把fd中的数据读完的，两者矛盾，会导致不接受新到来的fd。
ET需要用到的是自定义的read函数，如下所示：
57 int read_fd(int sock,char *buf,int size)
58 {
59 int _size=-1;
60 int index=0;
61 while((_size=read(sock,buf+index,size-index)))
62 {
63 if(_size<0&&errno==EAGAIN)
64 {
65 break;
66 }
67 index+=_size;
68 _size=-1;
69 }
70 return index;
71 }
//因为ET模式的特点必须保证一次把整个sock中的一次数据全部读完，不然如果没有下次的数据
//到来，前面没有读完的数据就会永久性的丢失了。
//当read读到sock中整个数据流的最末尾的时候会产生一个类似errno的信号EAGAIN告诉它已经
//读到了sock中的最后一个数据。下面是一个epollET模式下的client与server
1 #include<stdio.h>
2 #include<stdlib.h>
3 #include<sys/socket.h>
4 #include<sys/types.h>
5 #include<arpa/inet.h>
6 #include<netinet/in.h>
7 #include<sys/epoll.h>
8 #include<fcntl.h>
9 #include<errno.h>
10 #include<string.h>
11 #include<unistd.h>
12
13 #define _MAX_LISTEN_ 6
14 #define _MAX_EPFD_ 64
15 #define _MAX_BUF_ 1024
16
17 void nonblock(int sock)
18 {
19 int fl=fcntl(sock,F_GETFL);
20 if(fl<0)
21 {
22 perror("fcntl");
23 exit(2);
24 }
25 if(fcntl(sock,F_SETFL,fl|O_NONBLOCK)<0)
26 {
27 exit(3);
28 }
29 }
30 int Listensock(char *ip,int port)
31 {
32 int sock=socket(AF_INET,SOCK_STREAM,0);
33 if(sock<0)
34 {
35 perror("socket");
36 exit(1);
37 }
38 nonblock(sock);
39 struct sockaddr_in local;
40 local.sin_addr.s_addr=inet_addr(ip);
41 local.sin_port=htons(port);
42
43 if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
44 {
45 perror("bind");
46 }
47
48 if(listen(sock,_MAX_LISTEN_)<0)
49 {
50 perror("listen");
51 } }
52
53 return sock;
54
55 }
56
57 int read_fd(int sock,char *buf,int size)
58 {
59 int _size=-1;
60 int index=0;
61 while((_size=read(sock,buf+index,size-index)))
62 {
63 if(_size<0&&errno==EAGAIN)
64 {
65 break;
66 }
67 index+=_size;
68 _size=-1;
69 }
70 return index;
71 }
72 void epollserver(int sock)
73 {
74 int epfd=epoll_create(256);
75
76 if(epfd<0)
77 {
78 perror("epoll_create");
79 exit(4);
80 }
81
82 struct epoll_event ev;
83 ev.data.fd=sock;
84 ev.events=EPOLLIN|EPOLLET;
85
86 if(epoll_ctl(epfd,EPOLL_CTL_ADD,sock,&ev)<0)
87 {
88 perror("epoll_ctl");
89 exit(5);
90 }
91 struct epoll_event epfds[_MAX_EPFD_];
92
93 int fd=-1;
94 int i;
95 for(i=0;i<_MAX_EPFD_;i++)
96 {
97 epfds[i].data.fd=fd;
98 }
99 int timeout=5000;
100
101 int fdlen=0;
102 while(1)
103 {
104 switch(fdlen=epoll_wait(epfd,epfds,_MAX_EPFD_,timeout))
105 {
106 case -1:
107 {
108 perror("epoll_wait");
109 continue;
110 }
111 case 0:
112 {
113 printf("timeout\n");
114 }
115 default:
116 {
117 struct sockaddr_in client;
118 int client_len=sizeof(client);
119 int i=0;
120 for(i=0;i<fdlen;i++)
121 {
122 int retfd=epfds[i].data.fd;
123 if(retfd==sock&&(epfds[i].events&EPOLLIN))
124 {
125 int recvfd=accept(sock,(struct sockaddr*)126 &client,&client_len);
127 if(recvfd<0)
128 {
129 continue;
130 }
131 else
132 {
133 nonblock(recvfd);
134 ev.data.fd=recvfd;
135 ev.events=EPOLLIN|EPOLLET;
136 if(epoll_ctl(epfd,EPOLL_CTL_ADD,recvfd,&ev)<0)
137 {
138 perror("epoll_ctl");
139 continue;
140 }
141 printf("a client come..ip=%s\n",142 inet_ntoa(client.sin_addr));
143
144 }
145 }
146 else if (epfds[i].events&EPOLLIN)
147 { {
148 char buf[_MAX_BUF_];
149 memset(buf,‘\0‘,_MAX_BUF_);
150 int ret=read_fd(retfd,buf,_MAX_BUF_);
151 if(ret>0)
152 {
153 buf[ret-1]=‘\0‘;
154 printf("client ::%s\n",buf);
155 fflush(stdout);
156 }else if(ret==0){
157 printf("ip=%s client is leave...\n",158 inet_ntoa(client.sin_addr));
159 }else{
160 //doing noting
161 }
162 }//else{此处可以改成回显}
163 }
164 }
165
166 }
167 }
168
169 int main(int argc,char *argv[])
170 {
171 if(argc!=3) if(argc!=3)
172 {
173 printf("[%s][ip][port]\n",argv[0]);
174 }
175 char *ip=argv[1];
176 int port=atoi(argv[2]);
177 int sock=Listensock(ip,port);
178
179 int opt=1;
180
181 if(setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt))<0)
182 {
183 perror("setsockopt");
184 }
185
186 epollserver(sock);
187
188 return 0;
189 }
改为回显模式：
当读完client的数据后，可以将event改为EPOLLOUT然后将读到的数据保存起来
当下次写事件发生时，将保存的数据扔出去。
注意：因为结构体中的data是一个联合体，当我们存放完fd后再去存放ptr有可能
会有bug，这里的方法是让ptr指向一个结构体，这个结构体中保存着fd和buf。
typedef struct p_buf{
int fd;
char outbuf[_MAX_BUF_];
}p_buf;
//自定义的缓冲区
164 else if (epfds[i].events&EPOLLIN)
166 {
167 ptrbuf *p_buf=(ptrbuf *)malloc(sizeof(ptrbuf));
//将数据直接读到自定义的缓冲区中
168 memset(p_buf->outbuf,‘\0‘,sizeof(p_buf->outbuf));
169 p_buf->fd=retfd;
170 int ret=read_fd(retfd,p_buf->outbuf,_MAX_BUF_);
171
172 if(ret>0)
173 {
174 p_buf->outbuf[ret-1]=‘\0‘;
175 printf("client ::%s\n",p_buf->outbuf);
176 fflush(stdout);
177 ev.events=EPOLLOUT|EPOLLET;
178 ev.data.ptr=p_buf;
//设置为EPOLLOUT模式
179 if(epoll_ctl(epfd,EPOLL_CTL_MOD,retfd,&ev)<0)
180 {
181 perror("epoll_ctl");
182 continue;
183 }
184 }else if(ret==0){
185 if(epoll_ctl(epfd,EPOLL_CTL_DEL,retfd,NULL)<0)
186 {
187 perror("epoll_ctl");
188 }
189 printf("ip=%s client is leave...\n",190 inet_ntoa(client.sin_addr));
191 }else{
192 //doing noting
193 }
194 }else{//当写条件满足时，回显消息并且改回为EPOLLIN模式
195 ptrbuf* outptr=(ptrbuf*)epfds[i].data.ptr;
196 int outfd=outptr->fd;
197 outptr->outbuf[strlen(outptr->outbuf)]=‘\n‘;
198 out_write(outfd,outptr->outbuf,_MAX_BUF_);
199 free(outptr);
200 ev.events=EPOLLIN|EPOLLET;
201 ev.data.fd=outfd;
202 if(epoll_ctl(epfd,EPOLL_CTL_MOD,outfd,&ev)<0)
203 {
204 perror("epoll_ctl");
205 }
206 }
207 }
208 }
209 }
210 }
211 }
212
194,6-24 96% 183,8-32 81%回显模式：
总结：
epoll对比之前的select和poll都有不小的改进，不用遍历整个buf，没有大小限制，并且有不同的模式可以选择，效率之高可想而知。
本文出自 “痕迹” 博客，请务必保留此出处http://wpfbcr.blog.51cto.com/10696766/1790742
以上是关于多路复用epoll的主要内容，如果未能解决你的问题，请参考以下文章