read(pipe_0,buf,sizeof(buf));    //sleep
print buf;
read(pipe_1,buf,sizeof(buf));
print buf;
read(pipe_2,buf,sizeof(buf));
print buf;

fd_set   //創(chuàng)建fd_set對象，將來從中增減需要監(jiān)視的fd
FD_ZERO()  //清空fd_set對象
FD_SET()  //將一個fd加入fd_set對象中 
select()  //監(jiān)視fd_set對象中的文件描述符
pselect()  //先設(shè)定信號屏蔽，再監(jiān)視
FD_ISSET() //測試fd是否屬于fd_set對象
FD_CLR()  //從fd_set對象中刪除fd

#define BUFSIZE 100
#define MAXNFD 1024 

int main()
{
  /***********服務(wù)器的listenfd已經(jīng)準本好了**************/
  fd_set readfds;
  fd_set writefds;
  FD_ZERO(&readfds);
  FD_ZERO(&writefds);
  FD_SET(listenfd, &readfds);

  fd_set temprfds = readfds;
  fd_set tempwfds = writefds;
  int maxfd = listenfd;


  int nready;
  char buf[MAXNFD][BUFSIZE] = {0};
  while(1){
    temprfds = readfds;
    tempwfds = writefds;

    nready = select(maxfd+1, &temprfds, &tempwfds, NULL, NULL)
    if(FD_ISSET(listenfd, &temprfds))｛     
      //如果監(jiān)聽到的是listenfd就進行accept
      int sockfd = accept(listenfd, (struct sockaddr*)&clientaddr, &len);
      
      //將新accept的scokfd加入監(jiān)聽集合，并保持maxfd為最大fd
      FD_SET(sockfd, &readfds);
      maxfd = maxfd>sockfd?maxfd:sockfd;
      
      //如果意見檢查了nready個fd，就沒有必要再等了，直接下一個循環(huán)
      if(--nready==0)
        continue;
    }
    
    int fd = 0;
    //遍歷文件描述符表，處理接收到的消息
    for(;fd<=maxfd; fd++)｛  
      if(fd == listenfd)
        continue;

      if(FD_ISSET(fd, &temprfds)){
        int ret = read(fd, buf[fd], sizeof buf[0]);
        if(0 == ret)｛  //客戶端鏈接已經(jīng)斷開
          close(fd);
          FD_CLR(fd, &readfds);
          if(maxfd==fd) 
            --maxfd;
          continue;
        }
        //將fd加入監(jiān)聽可寫的集合
        FD_SET(fd, &writefds); 
      }
      //找到了接收消息的socket的fd，接下來將其加入到監(jiān)視寫的fd_set中
      //將在下一次while()循環(huán)開始監(jiān)視
      if(FD_ISSET(fd, &tempwfds)){
        int ret = write(fd, buf[fd], sizeof buf[0]);
        printf("ret %d: %d\n", fd, ret);
        FD_CLR(fd, &writefds);
      }
    }
  }
  close(listenfd);
}

struct pollfd  fds   //創(chuàng)建一個pollfd類型的數(shù)組
fds[0].fd        //向fds[0]中放入需要監(jiān)視的fd
fds[0].events      //向fds[0]中放入需要監(jiān)視的fd的觸發(fā)事件
  POLLIN       //I/O有輸入
  POLLPRI       //有緊急數(shù)據(jù)需要讀取
  POLLOUT       //I/O可寫
  POLLRDHUP      //流式套接字連接斷開或套接字處于半關(guān)閉狀態(tài)
  POLLERR       //錯誤條件(僅針對輸出)
  POLLHUP       //掛起(僅針對輸出)
  POLLNVAL      //無效的請求：fd沒有被打開(僅針對輸出)

/* ... */

int main()
{
  /* ... */
  struct pollfd myfds[MAXNFD] = {0};
  myfds[0].fd = listenfd;
  myfds[0].events = POLLIN;
  int maxnum = 1;
  
  int nready;
  //準備二維數(shù)組buf，每個fd使用buf的一行，數(shù)據(jù)干擾
  char buf[MAXNFD][BUFSIZE] = {0};
  while(1){
    //poll直接返回event被觸發(fā)的fd的個數(shù)
    nready = poll(myfds, maxnum, -1)
    int i = 0;
    for(;i<maxnum; i++){
      //poll通過將相應(yīng)的二進制位置一來表示已經(jīng)設(shè)置
      //如果下面的條件成立，表示revent[i]里的POLLIN位已經(jīng)是1了
      if(myfds[i].revents & POLLIN){
        if(myfds[i].fd == listenfd){
          int sockfd = accept(listenfd, (struct sockaddr*)&clientaddr, &len);
          //將新accept的scokfd加入監(jiān)聽集合
          myfds[maxnum].fd = sockfd;
          myfds[maxnum].events = POLLIN;
          maxnum++;
          
          //如果意見檢查了nready個fd，就直接下一個循環(huán)
          if(--nready==0)
            continue;
        }
        else{
          int ret = read(myfds[i].fd, buf[myfds[i].fd], sizeof buf[0]);
          if(0 == ret)｛  //如果連接斷開了
            close(myfds[i].fd);
            
             //初始化將文件描述符表所有的文件描述符標記為-1
             //close的文件描述符也標記為-1
             //打開新的描述符時從表中搜索第一個-1
             //open()就是這樣實現(xiàn)始終使用最小的fd
             //這里為了演示并沒有使用這種機制
             myfds[i].fd = -1; 
            continue;
          }
          myfds[i].events = POLLOUT;
        }
      }
      else if(myfds[i].revents & POLLOUT){
        int ret = write(myfds[i].fd, buf[myfds[i].fd], sizeof buf[0]);
        myfds[i].events = POLLIN;
      }
    }
  }
  close(listenfd);
}

epoll_create()     //創(chuàng)建epoll對象
struct epoll_event   //準備事件結(jié)構(gòu)體和事件結(jié)構(gòu)體數(shù)組
  event.events
  event.data.fd ...
epoll_ctl()       //配置epoll對象
epoll_wait()      //監(jiān)控epoll對象中的fd及其相應(yīng)的event

/* ... */

int main()
{
  /* ... */
  /* 創(chuàng)建epoll對象 */
  int epoll_fd = epoll_create(1024);
  
  //準備一個事件結(jié)構(gòu)體
  struct epoll_event event = {0};
  event.events = EPOLLIN;
  event.data.fd = listenfd;  //data是一個共用體，除了fd還可以返回其他數(shù)據(jù)
  
  //ctl是監(jiān)控listenfd是否有event被觸發(fā)
  //如果發(fā)生了就把event通過wait帶出。
  //所以，如果event里不標明fd，我們將來獲取就不知道哪個fd
  epoll_ctl(epoll_fd, EPOLL_CTL_ADD, listenfd, &event);
  
  struct epoll_event revents[MAXNFD] = {0};
  int nready;
  char buf[MAXNFD][BUFSIZE] = {0};
  while(1){
    //wait返回等待的event發(fā)生的數(shù)目
    //并把相應(yīng)的event放到event類型的數(shù)組中
    nready = epoll_wait(epoll_fd, revents, MAXNFD, -1)
    int i = 0;
    for(;i<nready; i++){
      //wait通過在events中設(shè)置相應(yīng)的位來表示相應(yīng)事件的發(fā)生
      //如果輸入可用，那么下面的這個結(jié)果應(yīng)該為真
      if(revents[i].events & EPOLLIN){
        //如果是listenfd有數(shù)據(jù)輸入
        if(revents[i].data.fd == listenfd){
          int sockfd = accept(listenfd, (struct sockaddr*)&clientaddr, &len);
          struct epoll_event event = {0};
          event.events = EPOLLIN;
          event.data.fd = sockfd;
          epoll_ctl(epoll_fd, EPOLL_CTL_ADD, sockfd, &event);
        }
        else{
          int ret = read(revents[i].data.fd, buf[revents[i].data.fd], sizeof buf[0]);
          if(0 == ret){
            close(revents[i].data.fd);
            epoll_ctl(epoll_fd, EPOLL_CTL_DEL, revents[i].data.fd, &revents[i]);
          }
          
          revents[i].events = EPOLLOUT;
          epoll_ctl(epoll_fd, EPOLL_CTL_MOD, revents[i].data.fd, &revents[i]);
        }
      }
      else if(revents[i].events & EPOLLOUT){
        int ret = write(revents[i].data.fd, buf[revents[i].data.fd], sizeof buf[0]);
        revents[i].events = EPOLLIN;
        epoll_ctl(epoll_fd, EPOLL_CTL_MOD, revents[i].data.fd, &revents[i]);
      }
    }
  }
  close(listenfd);
}