struct eventpoll{
 ....
 /*紅黑樹的根節(jié)點，這顆樹中存儲著所有添加到epoll中的需要監(jiān)控的事件*/
 struct rb_root rbr;
 /*雙鏈表中則存放著將要通過epoll_wait返回給用戶的滿足條件的事件*/
 struct list_head rdlist;
 ....
};

struct epitem{
 struct rb_node rbn;//紅黑樹節(jié)點
 struct list_head rdllink;//雙向鏈表節(jié)點
 struct epoll_filefd ffd; //事件句柄信息
 struct eventpoll *ep; //指向其所屬的eventpoll對象
 struct epoll_event event; //期待發(fā)生的事件類型
}

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

struct epoll_event ev;
//設置與要處理的事件相關的文件描述符
ev.data.fd=listenfd;
//設置要處理的事件類型
ev.events=EPOLLIN|EPOLLET;
//注冊epoll事件
epoll_ctl(epfd,EPOLL_CTL_ADD,listenfd,&ev);

/*
* file epollTest.c
*/
#include <stdio.h> 
#include <stdlib.h> 
#include <unistd.h> 
#include <errno.h> 
#include <sys/socket.h> 
#include <netdb.h> 
#include <fcntl.h> 
#include <sys/epoll.h> 
#include <string.h> 

#define MAXEVENTS 64 

//函數(shù): 
//功能:創(chuàng)建和綁定一個TCP socket 
//參數(shù):端口 
//返回值:創(chuàng)建的socket 
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; 
} 


//函數(shù) 
//功能:設置socket為非阻塞的 
static int 
make_socket_non_blocking (int sfd) 
{ 
 int flags, s; 

 //得到文件狀態(tài)標志 
 flags = fcntl (sfd, F_GETFL, 0); 
 if (flags == -1) 
 { 
  perror ("fcntl"); 
  return -1; 
 } 

 //設置文件狀態(tài)標志 
 flags |= O_NONBLOCK; 
 s = fcntl (sfd, F_SETFL, flags); 
 if (s == -1) 
 { 
  perror ("fcntl"); 
  return -1; 
 } 

 return 0; 
} 

//端口由參數(shù)argv[1]指定 
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 (); 
 } 

 //除了參數(shù)size被忽略外,此函數(shù)和epoll_create完全相同 
 efd = epoll_create1 (0); 
 if (efd == -1) 
 { 
  perror ("epoll_create"); 
  abort (); 
 } 

 event.data.fd = sfd; 
 event.events = EPOLLIN | EPOLLET;//讀入,邊緣觸發(fā)方式 
 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; 
      } 
     } 

         //將地址轉(zhuǎn)化為主機名或者服務名 
     s = getnameinfo (&in_addr, in_len, 
         hbuf, sizeof hbuf, 
         sbuf, sizeof sbuf, 
         NI_NUMERICHOST | NI_NUMERICSERV);//flag參數(shù):以數(shù)字名返回 
         //主機地址和服務地址 

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