转自：风吹过夏天的ChinaUnix博客

6.1 ET模式为什么要设置在非阻塞模式下工作

    因为ET模式下的读写需要一直读或写直到出错（对于读，当读到的实际字节数小于请求字节数时就可以停止），而如果你的文件描述符如果不是非阻塞的，那这个一直读或一直写势必会在最后一次阻塞。这样就不能在阻塞在epoll_wait上了，造成其他文件描述符的任务饿死。

6.2 使用ET和LT的区别

LT：水平触发，效率会低于ET触发，尤其在大并发，大流量的情况下。但是LT对代码编写要求比较低，不容易出现问题。LT模式服务编写上的表现是：只要有数据没有被获取，内核就不断通知你，因此不用担心事件丢失的情况。

ET：边缘触发，效率非常高，在并发，大流量的情况下，会比LT少很多epoll的系统调用，因此效率高。但是对编程要求高，需要细致的处理每个请求，否则容易发生丢失事件的情况。

 

下面举一个列子来说明LT和ET的区别（都是非阻塞模式，阻塞就不说了，效率太低）：

采用LT模式下，如果accept调用有返回就可以马上建立当前这个连接了，再epoll_wait等待下次通知，和select一样。

但是对于ET而言，如果accpet调用有返回，除了建立当前这个连接外，不能马上就epoll_wait还需要继续循环accpet，直到返回-1，且errno==EAGAIN，

从本质上讲：与LT相比，ET模型是通过减少系统调用来达到提高并行效率的。

6.3 一道腾讯后台开发的面试题

    使用Linux epoll模型，水平（LT）触发模式，当socket可写时，会不停的触发socket可写的事件，如何处理？

第一种最普遍的方式：
需要向socket写数据的时候才把socket加入epoll，等待可写事件。接受到可写事件后，调用write或者send发送数据。当所有数据都写完后，把socket移出epoll。

这种方式的缺点是，即使发送很少的数据，也要把socket加入epoll，写完后在移出epoll，有一定操作代价。

一种改进的方式：
开始不把socket加入epoll，需要向socket写数据的时候，直接调用write或者send发送数据。如果返回EAGAIN，把socket加入epoll，在epoll的驱动下写数据，全部数据发送完毕后，再移出epoll。

这种方式的优点是：数据不多的时候可以避免epoll的事件处理，提高效率。

6.4什么情况下用ET

很简单，当你想提高程序效率的时候。

最后附一个epoll实例：

点击(此处)折叠或打开

1. #include <sys/socket.h>
2. #include <sys/wait.h>
3. #include <netinet/in.h>
4. #include <netinet/tcp.h>
5. #include <sys/epoll.h>
6. #include <sys/sendfile.h>
7. #include <sys/stat.h>
8. #include <unistd.h>
9. #include <stdio.h>
10. #include <stdlib.h>
11. #include <string.h>
12. #include <strings.h>
13. #include <fcntl.h>
14. #include <errno.h>
16. #define MAX_EVENTS 10
17. #define PORT 8080
19. //设置socket连接为非阻塞模式
20. void setnonblocking(int sockfd) {
21.     int opts;
22.     opts = fcntl(sockfd, F_GETFL);
23.     if(opts < 0) {
24.         perror("fcntl(F_GETFL)\n");
25.         exit(1);
26.     }
27.     opts = (opts | O_NONBLOCK);
28.     if(fcntl(sockfd, F_SETFL, opts) < 0) {
29.         perror("fcntl(F_SETFL)\n");
30.         exit(1);
31.     }
32. }
34. int main(){
35.     struct epoll_event ev, events[MAX_EVENTS]; //ev负责添加事件，events接收返回事件
36.     int addrlen, listenfd, conn_sock, nfds, epfd, fd, i, nread, n;
37.     struct sockaddr_in local, remote;
38.     char buf[BUFSIZ];
40.     //创建listen socket
41.     if( (listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
42.         perror("sockfd\n");
43.         exit(1);
44.     }
45.     setnonblocking(listenfd);//listenfd设置为非阻塞[1]
46.     bzero(&local, sizeof(local));
47.     local.sin_family = AF_INET;
48.     local.sin_addr.s_addr = htonl(INADDR_ANY);;
49.     local.sin_port = htons(PORT);
50.     if( bind(listenfd, (struct sockaddr *) &local, sizeof(local)) < 0) {
51.         perror("bind\n");
52.         exit(1);
53.     }
54.     listen(listenfd, 20);
56.     epfd = epoll_create(MAX_EVENTS);
57.     if (epfd == -1) {
58.         perror("epoll_create");
59.         exit(EXIT_FAILURE);
60.     }
62.     ev.events = EPOLLIN;
63.     ev.data.fd = listenfd;
64.     if (epoll_ctl(epfd, EPOLL_CTL_ADD, listenfd, &ev) == -1) {//监听listenfd
65.         perror("epoll_ctl: listen_sock");
66.         exit(EXIT_FAILURE);
67.     }
69.     for (;;) {
70.         nfds = epoll_wait(epfd, events, MAX_EVENTS, -1);
71.         if (nfds == -1) {
72.             perror("epoll_pwait");
73.             exit(EXIT_FAILURE);
74.         }
76.         for (i = 0; i < nfds; ++i) {
77.             fd = events[i].data.fd;
78.             if (fd == listenfd) {
79.                 while ((conn_sock = accept(listenfd,(struct sockaddr *) &remote,
80.                                 (size_t *)&addrlen)) > 0) {
81.                     setnonblocking(conn_sock);//下面设置ET模式，所以要设置非阻塞
82.                     ev.events = EPOLLIN | EPOLLET;
83.                     ev.data.fd = conn_sock;
84.                     if (epoll_ctl(epfd, EPOLL_CTL_ADD, conn_sock, &ev) == -1) {//读监听
85.                         perror("epoll_ctl: add"); //连接套接字
86.                         exit(EXIT_FAILURE);
87.                     }
88.                 }
89.                 if (conn_sock == -1) {
90.                     if (errno != EAGAIN && errno != ECONNABORTED
91.                             && errno != EPROTO && errno != EINTR)
92.                         perror("accept");
93.                 }
94.                 continue;
95.             }
96.             if (events[i].events & EPOLLIN) {
97.                 n = 0;
98.                 while ((nread = read(fd, buf + n, BUFSIZ-1)) > 0) {//ET下可以读就一直读
99.                     n += nread;
100.                 }
101.                 if (nread == -1 && errno != EAGAIN) {
102.                     perror("read error");
103.                 }
104.                 ev.data.fd = fd;
105.                 ev.events = events[i].events | EPOLLOUT; //MOD OUT
106.                 if (epoll_ctl(epfd, EPOLL_CTL_MOD, fd, &ev) == -1) {
107.                     perror("epoll_ctl: mod");
108.                 }
109.             }
110.             if (events[i].events & EPOLLOUT) {
111.               sprintf(buf, "HTTP/1.1 200 OK\r\nContent-Length: %d\r\n\r\nHello World", 11);
112.                 int nwrite, data_size = strlen(buf);
113.                 n = data_size;
114.                 while (n > 0) {
115.                     nwrite = write(fd, buf + data_size - n, n);//ET下一直将要写数据写完
116.                     if (nwrite < n) {
117.                         if (nwrite == -1 && errno != EAGAIN) {
118.                             perror("write error");
119.                         }
120.                         break;
121.                     }
122.                     n -= nwrite;
123.                 }
124.                 close(fd);
125.             }
126.         }
127.     }
128.     return 0;
129. }