多路复用I/O-epoll

struct epoll_event { 
  uint32_t events; // 表示监听的事件类型
  epoll_data_t data; // 用户数据，可以是指针或者整数值
 };

     EPOLLIN
              The associated file is available for read(2) operations.
       EPOLLOUT
              The associated file is available for write(2) operations.
       EPOLLRDHUP (since Linux 2.6.17)
              Stream socket peer closed connection, or shut down writing half of connection.  (This flag is especially  useful  for
       EPOLLOUT
              The associated file is available for write(2) operations.
       EPOLLRDHUP (since Linux 2.6.17)
              Stream socket peer closed connection, or shut down writing half of connection.  (This flag is especially  useful  for
              writing simple code to detect peer shutdown when using Edge Triggered monitoring.)
       EPOLLPRI
              There is urgent data available for read(2) operations.
       EPOLLERR
              Error condition happened on the associated file descriptor.  epoll_wait(2) will always wait for this event; it is not
              necessary to set it in events.
       EPOLLHUP
              Hang up happened on the associated file descriptor.  epoll_wait(2) will always wait for this event; it is not  neces‐
              sary to set it in events.  Note that when reading from a channel such as a pipe or a stream socket, this event merely
              indicates that the peer closed its end of the channel.  Subsequent reads from the channel will return 0 (end of file)
              only after all outstanding data in the channel has been consumed.
       EPOLLET
              Sets  the  Edge Triggered behavior for the associated file descriptor.  The default behavior for epoll is Level Trig‐
              gered.  See epoll(7) for more detailed information about Edge and Level Triggered event distribution architectures.
       EPOLLONESHOT (since Linux 2.6.2)
              Sets the one-shot behavior for the associated file descriptor.  This means that after an event  is  pulled  out  with
              epoll_wait(2) the associated file descriptor is internally disabled and no other events will be reported by the epoll
              interface.  The user must call epoll_ctl() with EPOLL_CTL_MOD to rearm the file descriptor with a new event mask.
       EPOLLWAKEUP (since Linux 3.5)
              If EPOLLONESHOT and EPOLLET are clear and the process has the CAP_BLOCK_SUSPEND capability, ensure  that  the  system
              does  not  enter "suspend" or "hibernate" while this event is pending or being processed.  The event is considered as
              being "processed" from the time when it is returned by a call to epoll_wait(2) until the next call  to  epoll_wait(2)
              on  the  same epoll(7) file descriptor, the closure of that file descriptor, the removal of the event file descriptor
              with EPOLL_CTL_DEL, or the clearing of EPOLLWAKEUP for the event file descriptor with EPOLL_CTL_MOD.  See also BUGS.

int epoll_create(int size)
参数 int size： 现无意义，必须大于0，一般填1，告知内核事件表有多大。
返回值：成功返回对应的 epfd ( event poll 结构体) ，失败返回 -1。

int epoll_ctl(int epfd, int op, int fd, struct epoll_event *event)
返回值：成功返回0，失败返回-1。
参数：
- 参数1 epfd：epoll对象/epoll实例标识符
- 参数2 op：指定操作类型。
  EPOLL_CTL_ADD 增加 将指定文件描述符加入到监听队列中；
  EPOLL_CTL_MOD 修改 修改已经加入监听队列中的文件描述符对应事件信息；
  EPOLL_CTL_DEL 删除 将已经加入监听队列中的文件描述符移除。
- 参数3 fd：要监听的句柄(fd)
- 参数4 event: 指向一个结构体变量，用来设置需要监听的事件类型以及相关属性 要监听的事件类型，红黑树键值对kv：fd-event
  event.events常用类型:
  EPOLLIN   可读
  EPOLLOUT    可写
  EPOLLET   边缘触发，默认⽔平触发LT
具体详解：
epoll_ctl主要是对epitem对象进行操作：把fd 和struct epoll_event{}绑定
EPOLL_CTL_ADD：先查看含fd的epitem对象是否在红黑树中，如果在则退出，不在则将fd和event加到epitem对象中并将该对象插入红黑树中。
EPOLL_CTL_DEL:先查看含fd的epitem对象是否在红黑树中，如果不在则退出，在则将该epitem对象从红黑树中删除。
EPOLL_CTL_MOD:先查看含fd的epitem对象是否在红黑树中，如果不在则退出，在则更新事件。

// 收集 epoll 监控的事件中已经发生的事件，如果 epoll 中没有任何⼀个事件发⽣，则最多等待 timeout 毫秒后返回。
int epoll_wait(int epfd, struct epoll_event *events, int maxevents, int timeout)
返回值：成功返回实际就绪的 fd 数量，失败返回-1
参数：
- 参数1 epfd：epoll 对象。
- 参数2 events：指向存储返回事件的结构体数组。 用户态创建的evnet数组，内核拷贝就绪的 fd 到该数组中。
    events[i].events:
    EPOLLIN     触发读事件
    EPOLLOUT    触发写事件
    EPOLLERR    连接发生错误
    EPOLLRDHUP    连接读端关闭
    EPOLLHUP    连接双端关闭
- 参数3 maxevents：可以返回的最⼤事件数目，一般设置为event数组的⻓度
- 参数4 timeout：超时时间 ms。-1(一直等待)，0(不等待)，>0(等待时间)。断开与服务器没有交互的客户端

fcntl 函数可以将 fd 设置为非阻塞。
//修改（获取）文件描述符属性
int fcntl(int fd, int cmd, ... /* arg */ );
返回值：失败返回-1
参数
- 参数1：需要修改的文件描述符，
- 参数2：修改（获取）文件描述符的操作

//1、获取原有套接字状态的信息
  int status = fcntl(fd, F_GETFL);
//2、将非阻塞的标志与原有的标志信息做或操作
  status |= O_NONBLOCK;
//3、将标志位信息写回到socket中
  fcntl(fd, F_SETFL, status);

// lt + 一次性读，小数据
ret = read(fd, buf, sizeof(buf));
// et + 循环读，大数据
while(true) {
    ret = read(fd, buf, sizeof(buf);
    // 此时，说明读缓冲区已经空了
    if (ret == EAGAIN || ret == EWOULDBLOCK) break;
}

ret = recv(newFd, buf, sizeof(buf)-1, MSG_DONTWAIT);

int conn_fd = 0;
// fd --> epoll  在epoll 底层创建的时候也是通过fd 操作的。
int epfd = epoll_create(1);//参数无意义只要大于0 即可；老版本参数是用来确定一次行就绪数量
struct epoll_event ev, events[EVENTS_LENGTH];
ev.events = EPOLLIN|EPOLLET;
ev.data.fd = listen_fd
epoll_ctl(epfd,EPOLL_CTL_ADD,listen_fd,&ev)  // 先把listen_fd 注册到事件中； 非阻塞，不可能在这个地方存在挂起
printf("fd : %d\n",epfd);
while(1){  //7*24   所有的服务器都有这个循环，做成永真的循环，while(!finshed) / for(;;)
    int nready = epoll_wait(epfd,events, EVENTS_LENGTH,1000); // 是阻塞
    printf("nready :%d",nready);
    int i = 0;
    for (i = 0; i < nready;i++){
        int clientfd = events[i].data.fd ;
        if (listen_fd == clientfd){  // accept处理
            while( 1) {
                struct sockaddr_in client_addr;
                socklen_t length = sizeof(client_addr);
                fcntl(listen_fd, F_SETFL, fcntl(listen_fd, F_GETFL, 0)|O_NONBLOCK);
                conn_fd = accept(listen_fd,(struct sockaddr *)&client_addr, &length);
                if (0 > conn_fd ) {
                    printf("accept socket error: %s(errno: %d)\n", strerror(errno), errno);
                    return 0;
                }
                if (conn_fd == -1){
                    break;
                }
                printf("accept  : %d\n",conn_fd);
                ev.events = EPOLLIN;
                ev.data.fd = conn_fd;
                epoll_ctl(epfd,EPOLL_CTL_ADD, conn_fd, &ev);
            }
        }else if(events[i].events & EPOLLIN)  {   // clientfd
           unsigned char buff[BUFF_LENGTH] = {0};
            int n = recv(clientfd, rbuff, BUFF_LENGTH,0);
            if (n > 0) {
                //rbuffer[n] = '\0';
                printf("recv: %s, n: %d\n", rbuffer, n);
                memcpy(wbuffer, rbuffer, BUFFER_LENGTH);
                ev.events = EPOLLOUT;
                ev.data.fd = clientfd;
                epoll_ctl(epfd, EPOLL_CTL_MOD, clientfd, &ev);
            } 
        }else if (events[i].events & EPOLLOUT) {
          int sent = send(clientfd, wbuffer, BUFFER_LENGTH, 0); //
      printf("sent: %d\n", sent);
      ev.events = EPOLLIN;
      ev.data.fd = clientfd;
      epoll_ctl(epfd, EPOLL_CTL_MOD, clientfd, &ev);
        }
    }
}