1.什么是epoll
epoll是什么？按照man手册的说法：是为处理大批量句柄而作了改进的poll，目的是为了得到已经就绪的文件描述符，当时间就绪是按顺序添加进去。
epoll的相关系统调用
epoll只有epoll_create,epoll_ctl,epoll_wait 3个系统调用。
1>. int epoll_create(int size);
创建一个epoll的句柄。自从linux2.6.8之后，size参数是被忽略的。需要注意的是，当创建好epoll句柄后，它就是会占用一个fd值，在linux下如果查看/proc/进程id/fd/，是能够看到这个fd的，所以在使用完epoll后，必须调用close()关闭，否则可能导致fd被耗尽。
2> int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event);
epoll的事件注册函数，它不同于select()是在监听事件时告诉内核要监听什么类型的事件，而是在这里先注册要监听的事件类型。
第一个参数是epoll_create()的返回值。
第二个参数表示动作，用三个宏来表示：
EPOLL_CTL_ADD：注册新的fd到epfd中；
EPOLL_CTL_MOD：修改已经注册的fd的监听事件；
EPOLL_CTL_DEL：从epfd中删除一个fd；
第三个参数是需要监听的fd。
第四个参数是告诉内核需要监听什么事，struct epoll_event结构如下：
typedef union epoll_data
{
void* ptr;
int fd;
_uint32_t u32;
_uint64_t u64
}epoll_data_t;
//感兴趣的事件和被触发的事件
struct epoll_event
{
epoll_data_t data;
_uint32_t events;
}
events可以是以下几个宏的集合：
EPOLLIN ：表示对应的文件描述符可以读（包括对端SOCKET正常关闭）；
EPOLLOUT：表示对应的文件描述符可以写；
EPOLLPRI：表示对应的文件描述符有紧急的数据可读（这里应该表示有带外数据到来）；
EPOLLERR：表示对应的文件描述符发生错误；
EPOLLHUP：表示对应的文件描述符被挂断；
EPOLLET： 将EPOLL设为边缘触发(Edge Triggered)模式，这是相对于水平触发(Level
Triggered)来说的。
EPOLLONESHOT：只监听一次事件，当监听完这次事件之后，如果还需要继续监听这个
socket的话，需要再次把这个socket加入到EPOLL队列里
3> int epoll_wait(int epfd, struct epoll_event * events, int maxevents, int timeout);
收集在epoll监控的事件中已经发送的事件。参数events是分配好的epoll_event结构体数组，
epoll将会把发生的事件赋值到events数组中（events不可以是空指针，内核只负责把数据复
制到这个events数组中，不会去帮助我们在用户态中分配内存）。maxevents告之内核这个
events有多大，这个 maxevents的值不能大于创建epoll_create()时的size，参数timeout是超时
时间（毫秒，0会立即返回，-1将不确定，也有说法说是永久阻塞）。如果函数调用成功，
返回对应I/O上已准备好的文件描述符数目，如返回0表示已超时。
2.epoll工作原理
epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。
另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。
3.epoll的2种工作方式-水平触发（LT）和边缘触发（ET）
水平触发(LT):
以LT方式调用epoll接口的时候，它就相当于一个速度比较快的poll，并且无论后面的数据是否被使用。
LT是epoll缺省的工作方式，并且同时支持block和no-block socket.在这种做法
中，内核告诉你一个文件描述符是否就绪了，然后你可以对这个就绪的fd进行IO操作。如果
你不作任何操作，内核还是会继续通知你的。
边缘触发(ET):只有在监视的文件句柄上发生了某个事件的时候 ET 工作模式才会汇报事件.即只会在数据到来时通知一次。
epoll工作在ET模式的时候，必须使用非阻塞套接口，以避免由于一个文件句柄的阻塞读/阻塞写操作把处理多个文件描述符的任务饿死.
I.基于非阻塞文件句柄.
II. 只有当read或者write返回EAGAIN时才需要挂起，等待。但这并不是说每次read()
时都需要循环读，直到读到产生一个EAGAIN才认为此次事件处理完成，当read()返回的读到的数据长度小于请求的数据长度时，就可以确定此时缓冲中已没有数据了，也就可以认为此事读事件已处理完成。
4.具体代码实现：
//epoll_server.c
1 #include<stdio.h>
2 #include<arpa/inet.h>
3 #include<sys/socket.h>
4 #include<sys/epoll.h>
5 #include<stdlib.h>
6 #include<errno.h>
7 #include<netinet/in.h>
8 #include<string.h>
9 #include<assert.h>
10 #include<fcntl.h>
11 #include<errno.h>
12 #define _MAX_ 20
13
14 typedef struct data_buf
15 {
16 int fd;
17 char buf[1024];
18 }data_buf_t,*data_buf_p;
19 static void SetNonBlock(int fd)
20 {
21 int fds=0;
22 if((fds=fcntl(fd,F_GETFL))<0)
23 {
24 perror("fcntl");
25 exit(1);
26 }
27 if(fcntl(fd,F_SETFL)<0)
28 {
29 perror("fcntl");
30 exit(2);
31 }
32
33
34
35 }
36 static void usage(const char*proc)
37 {
38 printf("usage: %s [ip] [port]",proc);
39
40 }
42 static int startup(int port,char*ip)
43 {
44 int sock=socket(AF_INET,SOCK_STREAM,0);
45 if(sock<0)
46 {
47 perror("socket");
48 exit(1);
49 }
50 struct sockaddr_in local;
51 local.sin_family=AF_INET;
52 local.sin_port=htons(port);
53 local.sin_addr.s_addr=inet_addr(ip);
54 if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
55 {
56 perror("bind");
57 exit(2);
58 }
59 if(listen(sock,5)<0)
60 {
61 perror("listen");
62 exit(2);
63 }
64 return sock;
65
66 }
67
68 static int read_data(int fd,char*buf,int size)//什么时候读完用EADAIN检测
69 {
70 printf("read_data\n");
71 assert(buf);
72 int index=0;
73 ssize_t ret=-1;
74 while(ret=read(fd,buf+index,size-index))
75 {
76 if(errno==EAGAIN)//客户端无数据发送
77 {
78 break;
79 }
80 index+=ret;
81
82 }
83
84 //printf("read_data\n");
85 return index;
86 }
87
88 static void write_data(int fd,char *buf)//什么时候写完
89
90 {
91
92 ssize_t len=strlen(buf);
93 int index=0;
94 int ret=0;
95 do
96 {
97 ret=write(fd,buf+index,len-index);
98 index+=ret;
99
100 }while(ret>0);
101
102 }
103 static int epoll_server(int sock)
104 {
105 //1.chuangjian
106 int epoll_fd= epoll_create(256);//创建epoll
107 if(epoll_fd<0)
108 {
109 perror("epoll_create");
110 return 1;
111 }
112 struct sockaddr_in client;
113 socklen_t len=sizeof(client);
114 //注册套接字信息
115 struct epoll_event ev;
116 ev.events=EPOLLIN;
117 ev.data.fd=sock;
118 SetNonBlock(sock);//将套接字设置为非阻塞
119 epoll_ctl(epoll_fd,EPOLL_CTL_ADD,sock,&ev);//将套接字添加到epoll
120 struct epoll_event ret_ev[_MAX_];
121 int ret_num=_MAX_;
122 int timeout=8000;
123 int ready_num=-1;
124 while(1)
125 {
//有多少准备就绪
126 switch(ready_num=epoll_wait(epoll_fd,ret_ev,ret_num,timeout))
127 {
128 case -1://error
129 perror("epoll_wait");
130 break;
131 case 0://timeout
132 printf("timeout\n");
133 break;
134 default:
135 {
136 int i=0;
137 for(;i<ready_num;++i)
138 {
//为listen_sock
140 if((ret_ev[i].data.fd==sock)&&(ret_ev[i].events&EPOLLIN))
141 {
142 int fd=ret_ev[i].data.fd;
143
144 int new_sock=accept(sock,(struct sockaddr*)&client,&len);
145 if(new_sock<0)
146 {
147 perror("accept");
148 continue;
149 }
150
151 printf("get connect...\n");
152 //将新的套接字添加到epoll
153 ev.events=EPOLLIN|EPOLLET;
154 ev.data.fd=new_sock;
155 epoll_ctl(epoll_fd,EPOLL_CTL_ADD,new_sock,&ev);
156
157 }
158
159 else if(ret_ev[i].events&EPOLLIN)
160 {
162 //可读就绪
163 int fd=ret_ev[i].data.fd;
164 // printf("%d\n",fd);
165 data_buf_p mem=(data_buf_p)malloc(sizeof(data_buf_t));
166 mem->fd=fd;
167
168 ssize_t s=read(mem->fd,mem->buf,sizeof(mem->buf)-1);
169 //ssize_t s=read_data(mem->fd,mem->buf,sizeof(mem->buf)-1) ;
170 printf("%d\n",s);
171 if(s>0)
172 {
173
174 mem->buf[s]='\0';
175 printf("client:%s\n",mem->buf);
176 //epoll_ctl(epoll_fd,EPOLL_CTL_DEL,fd,NULL);
177 ev.events=EPOLLOUT|EPOLLET;
178 ev.data.ptr=mem;
179 epoll_ctl(epoll_fd,EPOLL_CTL_MOD,fd,&ev);//将其修改为关心写
180 }
181
182 else if(s==0)
183 {
184 close(fd);
185 epoll_ctl(epoll_fd,EPOLL_CTL_DEL,fd,NULL);//删除套接字
186 free(mem);
187 }
188 else
189 {
190
191 printf("error\n");
192 }
193 }
194 //写就绪
195 else if(ret_ev[i].events&EPOLLOUT)
196 {
197 data_buf_p mem=(data_buf_p)ret_ev[i].data.ptr;
205 char*msg="HTTP/1.0 200 OK\r\n\r\nhello bit :)\r\n";
206
207 write_data(mem->fd,msg);
208 close(mem->fd);
212 epoll_ctl(epoll_fd,EPOLL_CTL_DEL,mem->fd,NULL);
213 free(mem);
214 }
215
216 }
217 }
218 break;
219 }
220 }
221 }
222 int main(int argc,char*argv[])
223 {
224 if(argc!=3)
225 {
226 usage(argv[0]);
227 return 1;
228 }
229 int port=atoi(argv[2]);
230 char* ip=argv[1];
231 int listen_sock=startup(port,ip);
232 int opt=1;//端口复用
233 setsockopt(listen_sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt)) ;
234 epoll_server(listen_sock);
235 close(listen_sock);
236
237 return 0;
238
239 }
//epoll_client.c
1 #include<stdio.h>
2 #include<errno.h>
3 #include<poll.h>
4 #include<string.h>
5 #include<sys/types.h>
6 #include<arpa/inet.h>
7 #include<netinet/in.h>
8 #include<sys/socket.h>
9 #include<stdlib.h>
10
11 static void usage(char *proc)
12 {
13 printf("usage: %s [ip] [port] ",proc);
14 }
15
16
17 int main(int argc, char*argv[])
18 {
19 if(argc!=3)
20 {
21 usage(argv[0]);
22 return 1;
23 }
24 int port=atoi(argv[2]);
25 char* ip=argv[1];
26 int sock=socket(AF_INET,SOCK_STREAM,0);
27 if(sock<0)
28 {
29 perror("socket");
30 exit(1);
31 }
32 struct sockaddr_in remote;
33 remote.sin_family=AF_INET;
34 remote.sin_port=htons(port);
35 remote.sin_addr.s_addr=inet_addr(ip);
36 int ret=connect(sock,(struct sockaddr*)&remote,sizeof(remote));
37 if(ret<0)
38 {
39 perror("coonect");
40 exit(3);
41
42 }
43 char buf[1024];
44 while(1)
45 {
46 memset(buf,'\0',sizeof(buf));
47 printf("please enter: ");
48 fflush(stdout);
49 ssize_t s=read(0,buf,sizeof(buf)-1);
50 if(s>0)
51 {
52 write(sock,buf,strlen(buf));
53
54 }
//回显消息
55 ssize_t size=read(sock,buf,sizeof(buf));
56 printf("server: %s\n",buf);
57
58 }
59 close(sock);
60 return 0;
61 }使用客户端运行结果：
使用浏览器运行结果：
epoll的优点：
1.支持一个进程打开大数目的socket描述符(FD)
2.IO效率不随FD数目增加而线性下降
3.使用mmap加速内核与用户空间的消息传递
4.内核微调
总结：
epoll到底为什么可以高速处理这么多并发连接呢？
首先要调用epoll_create建立一个epoll对象。参数size是内核保证能够正确处理的最大
句柄数，多于这个最大数时内核可不保证效果。
其次epoll_ctl可以操作上面建立的epoll，例如，将刚建立的socket加入到epoll中让其
监控，或者把 epoll正在监控的某个socket句柄移出epoll，不再监控它等等。
再者epoll_wait在调用时，在给定的timeout时间内，当在监控的所有句柄中有事件发生
时，就返回用户态的进程。
从上面的调用方式就可以看到epoll比select/poll的优越之处：因为后者每次调用时都要传
递你所要监控的所有socket给select/poll系统调用，这意味着需要将用户态的socket列表
copy到内核态，如果以万计的句柄会导致每次都要copy几十几百KB的内存到内核态，非常低
效。而我们调用epoll_wait时就相当于以往调用select/poll，但是这时却不用传递socket句
柄给内核，因为内核已经在epoll_ctl中拿到了要监控的句柄列表。所以，实际上在你调用
epoll_create后，内核就已经在内核态开始准备帮你存储要监控的句柄了，每次调epoll_ctl
只是在往内核的数据结构里塞入新的socket句柄。当一个进程调用epoll_creaqte方法时，
Linux内核会创建一个eventpoll结构体，这个结构体中有两个成员与epoll的使用方式密切
相关。http://blog.chinaunix.net/uid-24517549-id-4051156.html (可以查看)
