徹底學會使用epoll(六)——關於ET的若干問題總結

gettogetto發表於2017-03-26

徹底學會使用epoll(六)——關於ET的若干問題總結

——lvyilong316

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. }

相關文章