通過完整示例來理解如何使用 epoll

網路伺服器通常使用一個獨立的程序或執行緒來實現每個連線。由於高效能應用程式需要同時處理大量的客戶端，這種方法就不太好用了，因為資源佔用和上下文切換時間等因素影響了同時處理大量客戶端的能力。另一種方法是在一個執行緒中使用非阻塞 I/O，以及一些就緒通知方法，即當你可以在一個套接字上讀寫更多資料的時候告訴你。

本文介紹了 Linux 的 epoll(7) 機制，它是 Linux 最好的就緒通知機制。我們用 C 語言編寫了示例程式碼，實現了一個完整的 TCP 伺服器。我假設您有一定 C 語言程式設計經驗，知道如何在 Linux 上編譯和執行程式，並且可以閱讀手冊檢視各種需要的 C 函式。

epoll 是在 Linux 2.6 中引入的，在其他類 UNIX 作業系統上不可用。它提供了一個類似於 select

(2) 和 poll(2) 函式的功能：

select(2) 一次可以監測 FD_SETSIZE數量大小的描述符，FD_SETSIZE 通常是一個在 libc 編譯時指定的小數字。
poll(2) 一次可以監測的描述符數量並沒有限制，但撇開其它因素，我們每次都不得不檢查就緒通知，線性掃描所有通過描述符，這樣時間複雜度為 O(n)而且很慢。

epoll 沒有這些固定限制，也不執行任何線性掃描。因此它可以更高效地執行和處理大量事件。

一個 epoll 例項可由 epoll_create(2) 或 epoll_create1(2) （它們採用不同的引數）建立，它們的返回值是一個 epoll 例項。epoll_ctl

(2) 用來新增或刪除監聽 epoll 例項的描述符。epoll_wait(2) 用來等待被監聽的描述符事件，一直阻塞到事件可用。更多資訊請參見相關手冊。

當描述符被新增到 epoll 例項時，有兩種模式：電平觸發和邊緣觸發（譯者注：借鑑電路里面的概念）。當你使用電平觸發模式，並且資料可以被讀取，epoll_wait(2) 函式總是會返回就緒事件。如果你還沒有讀完資料，並且再次在 epoll 例項上呼叫 epoll_wait(2) 函式監聽這個描述符，由於還有資料可讀，那麼它會再次返回這個事件。在邊緣觸發模式下，你只會得到一次就緒通知。如果你沒有將資料全部讀走，並且再次在 epoll 例項上呼叫 epoll_wait(2) 函式監聽這個描述符，它就會阻塞，因為就緒事件已經發送過了。

傳遞到 epoll_ctl(2) 的 epoll 事件結構體如下。對每一個被監聽的描述符，你可以關聯到一個整數或者一個使用者資料的指標。

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 */
};

12345678910111213

typedefunionepoll_data{void*ptr;intfd;__uint32_t u32;__uint64_t u64;}epoll_data_t;structepoll_event{__uint32_t events;/* Epoll events */epoll_data_t data;/* User data variable */};

現在我們開始寫程式碼。我們將實現一個小的 TCP 伺服器，將傳送到這個套接字的所有資料列印到標準輸出上。首先編寫一個 create_and_bind() 函式，用來建立和繫結 TCP 套接字：

static int
create_and_bind (char *port)
{
  struct addrinfo hints;
  struct addrinfo *result, *rp;
  int s, sfd;

  memset (&hints, 0, sizeof (struct addrinfo));
  hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */
  hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
  hints.ai_flags = AI_PASSIVE;     /* All interfaces */

  s = getaddrinfo (NULL, port, &hints, &result);
  if (s != 0)
    {
      fprintf (stderr, "getaddrinfo: %sn", gai_strerror (s));
      return -1;
    }

  for (rp = result; rp != NULL; rp = rp->ai_next)
    {
      sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
      if (sfd == -1)
        continue;

      s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
      if (s == 0)
        {
          /* We managed to bind successfully! */
          break;
        }

      close (sfd);
    }

  if (rp == NULL)
    {
      fprintf (stderr, "Could not bindn");
      return -1;
    }

  freeaddrinfo (result);

  return sfd;
}

123456789101112131415161718192021222324252627282930313233343536373839404142434445

staticintcreate_and_bind(char*port){structaddrinfo hints;structaddrinfo*result,*rp;ints,sfd;memset(&hints,0,sizeof(structaddrinfo));hints.ai_family=AF_UNSPEC;/* Return IPv4 and IPv6 choices */hints.ai_socktype=SOCK_STREAM;/* We want a TCP socket */hints.ai_flags=AI_PASSIVE;/* All interfaces */s=getaddrinfo(NULL,port,&hints,&result);if(s!=0){fprintf(stderr,"getaddrinfo: %sn",gai_strerror(s));return-1;}for(rp=result;rp!=NULL;rp=rp->ai_next){sfd=socket(rp->ai_family,rp->ai_socktype,rp->ai_protocol);if(sfd==-1)continue;s=bind(sfd,rp->ai_addr,rp->ai_addrlen);if(s==0){/* We managed to bind successfully! */break;}close(sfd);}if(rp==NULL){fprintf(stderr,"Could not bindn");return-1;}freeaddrinfo(result);returnsfd;}

create_and_bind() 包含一個標準程式碼塊，用一種可移植的方式來獲得 IPv4 和 IPv6 套接字。它接受一個 port 字串引數，可由 argv[1] 傳遞。getaddrinfo(3) 函式返回一堆 addrinfo 結構體到 result變數中，它們與傳入的 hints引數是相容的。 addrinfo結構體像這樣：

struct addrinfo
{
  int              ai_flags;
  int              ai_family;
  int              ai_socktype;
  int              ai_protocol;
  size_t           ai_addrlen;
  struct sockaddr *ai_addr;
  char            *ai_canonname;
  struct addrinfo *ai_next;
};

1234567891011

structaddrinfo{intai_flags;intai_family;intai_socktype;intai_protocol;size_t ai_addrlen;structsockaddr*ai_addr;char*ai_canonname;structaddrinfo*ai_next;};

我們依次遍歷這些結構體並用它們建立套接字，直到可以建立並繫結一個套接字。如果成功了，create_and_bind( ) 返回這個套接字描述符。如果失敗則返回 -1。

下面我們編寫一個函式，用於將套接字設定為非阻塞狀態。make_socket_non_blocking() 為傳入的 sfd 引數設定 O_NONBLOCK 標誌：

static int
make_socket_non_blocking (int sfd)
{
  int flags, s;

  flags = fcntl (sfd, F_GETFL, 0);
  if (flags == -1)
    {
      perror ("fcntl");
      return -1;
    }

  flags |= O_NONBLOCK;
  s = fcntl (sfd, F_SETFL, flags);
  if (s == -1)
    {
      perror ("fcntl");
      return -1;
    }

  return 0;
}

12345678910111213141516171819202122

staticintmake_socket_non_blocking(intsfd){intflags,s;flags=fcntl(sfd,F_GETFL,0);if(flags==-1){perror("fcntl");return-1;}flags|=O_NONBLOCK;s=fcntl(sfd,F_SETFL,flags);if(s==-1){perror("fcntl");return-1;}return0;}

現在說說 main() 函式吧，它裡面包含了這個程式的事件迴圈。這是主要程式碼:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netdb.h>
#include <unistd.h>
#include <fcntl.h>
#include <sys/epoll.h>
#include <errno.h>

#define MAXEVENTS 64

static int
make_socket_non_blocking (int sfd)
{
  int flags, s;

  flags = fcntl (sfd, F_GETFL, 0);
  if (flags == -1)
    {
      perror ("fcntl");
      return -1;
    }

  flags |= O_NONBLOCK;
  s = fcntl (sfd, F_SETFL, flags);
  if (s == -1)
    {
      perror ("fcntl");
      return -1;
    }

  return 0;
}

static int
create_and_bind (char *port)
{
  struct addrinfo hints;
  struct addrinfo *result, *rp;
  int s, sfd;

  memset (&hints, 0, sizeof (struct addrinfo));
  hints.ai_family = AF_UNSPEC;     /* Return IPv4 and IPv6 choices */
  hints.ai_socktype = SOCK_STREAM; /* We want a TCP socket */
  hints.ai_flags = AI_PASSIVE;     /* All interfaces */

  s = getaddrinfo (NULL, port, &hints, &result);
  if (s != 0)
    {
      fprintf (stderr, "getaddrinfo: %s\n", gai_strerror (s));
      return -1;
    }

  for (rp = result; rp != NULL; rp = rp->ai_next)
    {
      sfd = socket (rp->ai_family, rp->ai_socktype, rp->ai_protocol);
      if (sfd == -1)
        continue;

      s = bind (sfd, rp->ai_addr, rp->ai_addrlen);
      if (s == 0)
        {
          /* We managed to bind successfully! */
          break;
        }

      close (sfd);
    }

  if (rp == NULL)
    {
      fprintf (stderr, "Could not bind\n");
      return -1;
    }

  freeaddrinfo (result);

  return sfd;
}

int
main (int argc, char *argv[])
{
  int sfd, s;
  int efd;
  struct epoll_event event;
  struct epoll_event *events;

  if (argc != 2)
    {
      fprintf (stderr, "Usage: %s [port]\n", argv[0]);
      exit (EXIT_FAILURE);
    }

  sfd = create_and_bind (argv[1]);
  if (sfd == -1)
    abort ();

  s = make_socket_non_blocking (sfd);
  if (s == -1)
    abort ();

  s = listen (sfd, SOMAXCONN);
  if (s == -1)
    {
      perror ("listen");
      abort ();
    }

  efd = epoll_create1 (0);
  if (efd == -1)
    {
      perror ("epoll_create");
      abort ();
    }

  event.data.fd = sfd;
  event.events = EPOLLIN | EPOLLET;
  s = epoll_ctl (efd, EPOLL_CTL_ADD, sfd, &event);
  if (s == -1)
    {
      perror ("epoll_ctl");
      abort ();
    }

  /* Buffer where events are returned */
  events = calloc (MAXEVENTS, sizeof event);

  /* The event loop */
  while (1)
    {
      int n, i;

      n = epoll_wait (efd, events, MAXEVENTS, -1);
      for (i = 0; i < n; i++)
    {
      if ((events[i].events & EPOLLERR) ||
              (events[i].events & EPOLLHUP) ||
              (!(events[i].events & EPOLLIN)))
        {
              /* An error has occured on this fd, or the socket is not
                 ready for reading (why were we notified then?) */
          fprintf (stderr, "epoll error\n");
          close (events[i].data.fd);
          continue;
        }

      else if (sfd == events[i].data.fd)
        {
              /* We have a notification on the listening socket, which
                 means one or more incoming connections. */
              while (1)
                {
                  struct sockaddr in_addr;
                  socklen_t in_len;
                  int infd;
                  char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

                  in_len = sizeof in_addr;
                  infd = accept (sfd, &in_addr, &in_len);
                  if (infd == -1)
                    {
                      if ((errno == EAGAIN) ||
                          (errno == EWOULDBLOCK))
                        {
                          /* We have processed all incoming
                             connections. */
                          break;
                        }
                      else
                        {
                          perror ("accept");
                          break;
                        }
                    }

                  s = getnameinfo (&in_addr, in_len,
                                   hbuf, sizeof hbuf,
                                   sbuf, sizeof sbuf,
                                   NI_NUMERICHOST | NI_NUMERICSERV);
                  if (s == 0)
                    {
                      printf("Accepted connection on descriptor %d "
                             "(host=%s, port=%s)\n", infd, hbuf, sbuf);
                    }

                  /* Make the incoming socket non-blocking and add it to the
                     list of fds to monitor. */
                  s = make_socket_non_blocking (infd);
                  if (s == -1)
                    abort ();

                  event.data.fd = infd;
                  event.events = EPOLLIN | EPOLLET;
                  s = epoll_ctl (efd, EPOLL_CTL_ADD, infd, &event);
                  if (s == -1)
                    {
                      perror ("epoll_ctl");
                      abort ();
                    }
                }
              continue;
            }
          else
            {
              /* We have data on the fd waiting to be read. Read and
                 display it. We must read whatever data is available
                 completely, as we are running in edge-triggered mode
                 and won't get a notification again for the same
                 data. */
              int done = 0;

              while (1)
                {
                  ssize_t count;
                  char buf[512];

                  count = read (events[i].data.fd, buf, sizeof buf);
                  if (count == -1)
                    {
                      /* If errno == EAGAIN, that means we have read all
                         data. So go back to the main loop. */
                      if (errno != EAGAIN)
                        {
                          perror ("read");
                          done = 1;
                        }
                      break;
                    }
                  else if (count == 0)
                    {
                      /* End of file. The remote has closed the
                         connection. */
                      done = 1;
                      break;
                    }

                  /* Write the buffer to standard output */
                  s = write (1, buf, count);
                  if (s == -1)
                    {
                      perror ("write");
                      abort ();
                    }
                }

              if (done)
                {
                  printf ("Closed connection on descriptor %d\n",
                          events[i].data.fd);

                  /* Closing the descriptor will make epoll remove it
                     from the set of descriptors which are monitored. */
                  close (events[i].data.fd);
                }
            }
        }
    }

  free (events);

  close (sfd);

  return EXIT_SUCCESS;
}

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182

通過完整示例來理解如何使用 epoll

通過完整示例來理解如何使用 epoll

通過簡單例子來理解先驗分佈、後驗分佈、似然估計&&貝葉斯公式

通過經典題目來理解多種閉包實現方式

CAS 5.1.x 的搭建和使用（三）—— 通過官方示例來熟悉客戶端搭建

通過反編譯字節碼來理解 Java 枚舉

Service 服務發現的兩種方式-通過案例來理解

C# 通過 Observer觀察者設計模式來理解抽象類和介面應用在什麼地方

yield 的本質-通過send來理解

以太坊dapp智慧合約示例——通過對映使用者來玩彩票

Dagger2使用攻略---通過生成的程式碼來理解相關概念

通過示例來學習ES2016, 2017, 2018的新特性

通過leetcode中的兩數之和耗時最少的程式來理解查詢其實可以不用先賦值

曹工說Redis原始碼（4）-- 通過redis server原始碼來理解 listen 函式中的 backlog 引數

Android與H5互調（通過實例來了解Hybrid App）

C# 用實例來理解IComparable和IComparer

磁盤I/O高居不下，通過什麽來查看占用I/O的進程？

通過traceur.js來編寫ES6

黃錦宣：用戶思維，通過用戶來獲取用戶

動畫效果詳情請看 jQuery api 動畫收放 slideUp slideDown 通過id class 來設置 jQuery實現效果

C語言編程之--scanf()函數與getchar()函數搭配來理解C程序的輸入緩存(buffer)

通過完整示例來理解如何使用 epoll

相關推薦