I/O复用

1.使得程序能同时监听多个文件描述符。使用情况：

• 客户端程序要同时处理多个socket。
• 客户端程序要同时处理用户输入和网络连接。
• TCP服务器要同时处理监听socket和连接socket。
• 服务器要同时处理TCP请求和UDP请求
• 服务器要同时监听多个端口，或处理多种服务

虽然能同时监听多个文件描述符，但它本身是阻塞的，当多个文件描述符同时就绪时，不采取措施，程序只能按照次序处理其中的每一个文件描述符。

1.select系统调用：

在一段指定时间内，监听用户感兴趣的文件描述符上的可读，可写和异常等事件，

select Api：

#include<sys/select.h>
int select (int nfds,fd_set* readfds,fd_set* 
writefds,fd_set* exceptfds,struct timeval* timeout);

nfds:指定被监听的文件描述符的总数，通常为监听的所有文件描述符中的最大值+1，因为文件描述符时从0开始计数

readfds，writefds，exceptfds分别指向可读，可写和异常等事件对应的文件描述符集合。当select调用返回时，内核将修改他们来通知应用程序那些文件描述符已经就绪。。。。fd_set结构体仅包含一个整型数组，该数组的每个元素的每一位标记一个文件描述符。

由于位操作过于频繁，使用宏来访问位
#incldue<sys/select.h>
FD_ZERO(fd_set *fdset); 清除fdset所有位
FD_SET（int fd，fd_set* fdset）； 设置位fd
FD_CLR（int fd，fd_set* fdset）；清除位fd
int FD_ISSET(int fd，fd_set* fdset)；测试位fd是否被设置

timeout设置select函数的超时时间，是一个timeval结构体类型的指针，内核将修改它告诉应用程序select等待了多久，但是如果调用失败timeout的值是不确定的

struct timeval
{
    long tv_sec;  秒数
    long tv_usec; 微秒数
}；

如果给timeout变量的成员传递0，则select将立即返回。传递NULL则会一直阻塞，直到某个文件描述符就绪

select成功返回就绪文件描述符的总数，如果在超时时间内没有任何文件描述符就绪，select返回0，失败返回-1，设置errno

文件描述符的就绪条件：

可读 1.socket内核接受缓存区中的字节数大于或等于其低水位标记SO_REVLOWAT。此时可以无阻塞的读socket，读操作的返回字节都大于0.........2.socket通信的对方关闭连接，此时读操作返回0.......3.监听socket上有新的连接请求........4.socket上有未处理的错误。用getsockopt来读取和清除该错误

可写：1.socket内核发送缓冲区中的可用字节数大于或等于其低水位标记SO_SNDLOWAT。无阻塞的写.......2.socket的写操作被关闭，再执行写操作将触发一个SIGPIPE信号.........3.socket使用非阻塞connect连接成功或失败之后........4.socket上有未处理的错误，

异常：有带外数据。

char buf[1024];
fd_set read_fds;
fd_set exception_fds;
FD_ZERO(&read_fds);
FD_ZERO(&exception_fds);

while(1)
{
    memset(buf,'\0',sizeof(buf));
每次调用select前都要重新再raed_fds和exception_fds
中设置文件描述符connfd
    FD_SET(connfd，&read_fds);
    FD_SET(commfd,&exception_fds);
    ret = select(connfd+1,&read_fds,NILL,
    &exception_fds,NULL);
    if(ret <0)
    {
        printf("selection failure\n");
        break;
    }
对于可读事件，recv函数读取数据
    if(FD_ISSET(connfd,&read_fds))
    {
        ret = recv(connfd,buf,sizeof(buf)-1,0);
        if(ret <= 0)
        {
            break;
        }
        printf("get %d bytes of normal data:
        %s\n",ret,buf);
    }
对于异常事件，用带MSG_OOB标志的recv读取
    else if(FD_ISSET(connfd,&excepption_fds))
    {
        ret = recv(connfd,buf,sizeof(buf)-1,MSG_OOB);
        if(ret <= 0)
        {
            break;
        }
        printf("get %d bytes of oob data:
        %s\n",ret,buf);
    }
    close(connfd);
    close(listenfd);
    return 0;
}

2.poll系统调用：

指定时间内轮询一定数量的文件描述符，以测试其中是否有就绪者。

#include<poll.h>
int poll(struct pollfd* fds,nfds_t nfds,
int timeout);

fds是pollfd结构类型的数组，指定我们感兴趣的文件描述符上发生的可读，可写异常等事件

struct pollfd
{
    int fd; 文件描述符
    short events; 注册的事件
    short revents; 实际发生的事件，内核填充
}

fd指定文件描述符，events告诉poll监听fd上的那些事件，是一系列事件的按位或。revents由内核修改，以通知程序fd上实际发生了那些事件，

• POLLIN:数据可读
• POLLRDNORM:普通数据可读
• POLLRDBAND:优先级带数据可读 POLLPRI:高优先级数据可读 POLLOUT:数据可写 POLLWRNORM:普通数据可写 POLLWRBAND:优先级带数据可写 POLLRDHUP：TCP连接被对方关闭， POLLERR:错误 POLLHUP:挂起，比如管道的写关闭 POLLNVAL：文件描述符没有打开

nfds指定被监听事件集合的fds大小，

typedef unsigned long int nfds_t

timeout指定poll的超时值，单位为毫秒，当为-1时，poll将永远阻塞，直到某个事件发生，为0，poll调用立即返回

3.epoll系列系统调用

内核事件表：Linux特有的I/O复用函数，使用一组函数来完成任务，epoll把用户关心的文件描述符上的事件放在内核的一个时间表中，需要使用额外的文件描述符来唯一表示内核中的这个事件表使用epoll_create函数创建：

#include<sys/epoll.h>
int epoll_create(int size);

size参数不起作用，只是告诉内核事件表需要多大。该函数返回的文件描述符将用作其他所有的epoll系统代用的第一个参数。

操作内核事件表
#include<sys/epoll.h>
int epoll_ctl(int epfd,int op,int fd,
struct epoll_event* event);

fd是要操作的文件描述符，op指定操作类型，（EPOLL_CTL_ADD:往事件表上注册fd上的事件，EPOLL_CTL_MOD：修改fd上的注册事件,EPOLL_CTL_DEL:删除fd上的注册事件）； event参数指定事件，是epoll_event结构的指针类型

struct epoll_event
{
    _uint32_t events;  epoll事件
    epoll_data_t data; 用户数据
}；

events成员描述事件类型，基本和poll相同，表示epoll事件的宏是在poll对应的宏前面加上“E”，但有两个额外的事件类型---EPOLLET和EPOLLONESHOT。

data存储用户数据
typedef union epoll_data
{
    void *ptr;
    int fd;
    uint32_t u32;
    uint64_t u64;
    
}epoll_data_t;

联合体，fd指定事件所从属的目标文件描述符。ptr用来指定与fd相关的用户数据。

epoll_ctl成功返回0，失败-1，设置errno

epoll_wait函数：

在一段超时时间内等待一组文件描述符上的事情

Einclude<sys/epoll.h>
int epoll_wait(int epfd,struct epoll_event* events,
int maxevents,int timeout);

成功返回就绪的文件描述符的个数，timeout与poll相同。。。maxevents指定最多监听多少个事件，必须大于0；如果检测到事件，就将所有就绪的事件从内核事件表中复制到他的第二个参数events指定的数组中，只用于输出检测到的就绪事件，

poll和epoll在使用上的区别
int ret = poll(fds,MAX_EVENT_NUMBER, -1);
必须遍历所有已注册文件描述符，
for(itn i= 0;i<MAX_EVENT_NUMBER;++i)
{判断底i个文件描述符是否就绪
    if(fds[i].reevents & POLLIN)
    {
        int sockfd = fds[i].fd;
        处理sockfd;
    }
}

int ret = epoll_wait(epollfd,events,MAX_EVENT_NUMBER,-1);
仅遍历就绪的ret个文件描述符
for(int i = 0;i<ret;i++)
{
    int sockfd = events[i].data.fd;
    坑定就绪直接处理
}

LT和ET模式：

• LT：电平触发：默认的工作模式，epoll相当于一个效率较高的poll。当epoll往内核事件表中注册一个文件描述符上的EPOLLET事件时，epoll将以ET模式操作该文件描述符。ET（边沿触发）是高效工作模式，检测到有事件发生，并将此事件通知程序，立即处理该事件，后续epoll_wait调用不再向程序通知这一事件。降低了同一个epoll事件被重复触发的次数

LT和ET
将文件描述符设置为非阻塞的
int setnonblocking(int fd)
{
    int old_option = fcntl(fd,F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd,F_SETFL,new_option);
    return old_option;
}
将文件描述符fd上的EPOLLIN注册到内核事件上
void addfd(int epollfd,int fd,bool enable_et)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLET;
    if(enable_et)
    {
        event.events |= EPOLLET;
    }
    epoll_ctl(epollfd,EPOLL_CTL_ADD,fd,&event);
    setnonblocking(fd);
}
LT模式的工作流程
void lt(epoll_event* events,int number,int
epollfd,int listenfd)
{
    char buf[BUFFER_SIZE];
    for(int i = 0;i<number;i++)
    {
        int sockfd = events[i].data.fd;
        if(sockfd == listenfd)
        {
            struct sockaddr_in client_address;
            socklen_t client_addrlength = 
            sizeof(client_address);
            int connfd = accept(listenfd,(struct 
            sockaddr*)&client_address,&client_addrlength);
            addfd(epollfd,connfd,false);
        }
    }
}

EPOLLONESHOT:事件

为了实现一个socket连接在任一时刻都只被一个线程处理，

对于注册了EPOLLONESHOT事件的文件描述符，系统最多触发其上注册的一个可读，可写，或异常事件，且只触发一次。除非我们用epoll_ctl重置。这样当一个线程在处理某个socket时，其他线程是不可能有机会操作此socket的。

与此同时，注册了EPOLLONESHOT的事件在处理完毕后，就应该立即重置，以确保这个socket在下一次可读时，其EPOLLIN事件能被触发

#include<sys/types.h>
3includde<sys/socket.h>
#include<netinet.h>
#include<arpa/inet.h>
#include<assert.h>
#include<stdio.h>
#include<unistd.h>
#include<errno.h>
#include<string.h>
#include<fcntl>
#include<stdlib.h>
#include<sys/epoll.h>
#include<pthread.h>
#define MAX_EVENT_NUMBER 1024
#defien BUFFER_SIZE 1024
struct fds
{
    int epollfd;
    int sockfd;
};
int setnonblocking(int fd)
{
    int old_option = fcntl(fd,F_GETFL);
    int new_option = old_option | O_NONBLOCK;
    fcntl(fd,F_SETFL,new_option);
    return old_option;
}
注册内核事件，oneset指定epolloneseet事件
void addfd(int epollfd,int fd,bool noeshot)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET;
    if(oneshot)
    {
        event.events |= EPOLLONESHOT;
    }
    epoll_ctl(epollfd,EPOLL_ATL_ADD,fd,&event);
    setnonblocking(fd);
}
重置fd上的事件,尽管fd上的EPOLLONESHOT被注册
但是操作系统任然会触发fd上的EPOLLIN事件
void reset_noeshot(int epollfd,int fd)
{
    epoll_event event;
    event.data.fd = fd;
    event.events = EPOLLIN | EPOLLET | EPOLLONESHOT;
    epoll_ctl(epollfd,EPOLL_CTL_MOD,fd,&event);
    
}
工作线程
void* worker(void* arg)
{
    int sockfd = ((fds*)arg)->sockfd;
    int epollds = ((fds*)arg)->epollfd;
    printf("start new thread to recive data
    on fd:%d\n",sockfd);
    char buf[BUFFER_ZISE];
    memset(buf,'\0',BUFFER_SIZE);
循环读取sockfd上的数据，直到EAGAIN错误
    while(1)
    {
        int ret = recv(sockfd,buf,BUFFER_ZISE-1,0);
        if(ret == 0)
        {
            close(sockfd);
            printf("foreiner closed the connection\n");
            break;
        }
        else if(ret < 0)
        {
            if(errno == EAGAIN)
            {
                reset_oneshot(epollfd,sockfd);
                printf("read later\n");
                break;
            }
        }
        else
        {
            printf("get content:%s\n",buf);
            sleep(5);
        }
    }
    printf("end thread receiving data on fd
    :%d\n",sockfd);
}

int main(int argc,char*argv[])
{
    if(argc <= 2)
    {
        
    }
    const char* ip = argv[1];
    int port = atoi(argv[2]);
    
    int ret = 0;
    struct sockaddr_in address;
    bzero(&address,sizeof(address);
    address.sin.family = AF_INET;
    inet_pton(AF_INET,ip,&address.sin_addr);
    将主机的字节序转换为网络字节序：
    即就是将高位与地位调换
    address.sin_port = htons(port);
    
    int listenfd = socket(PF_INET,SOCK_STREAM,0);
    assert(listenfd >= 0);
    
    ret = bind(listenfd,(atruct sockaddr*)&address,
    sizeof(address));
    assert(ret != -1)
    
    ret = listen(listenfd,5);
    assert(ret != -1);
    
    epoll_event events[MAX_EVENT_NUMBER];
    int epollfd = epoll_creat(5);
    assert(epollfd != -1);
    addfd(epollfd,listenfd,false);
    while(1)
    {
        int ret = epoll_wait(epollfd,events,
        MAX_EVENT_NUBMER,-1);
        if(ret < 0)
        {
            printf("epoll failure\n");
        }
        for(int i = 0;i <ret;i++)
        {
            int sockfd = events[i].data.fd;
            if(sockfd == listenfd)
            {
                struct sockaddr_in client_address;
                socklen_t client_addresslenth = 
                sizeof(client_address);
                int connfd = accept(listenfd,(struct 
                sockaddr*)&client_address,&client_addrlength);
                addfd(epollfd,connfd,true);
            }
            else if(events[i].events & EPOLLIN)
            {
                pthread_t thread;
                fds fds_for_new_woker;
                fds_for_new_worker.epollfd = epollfd;
                fds_for_new_worker.sockfd = sockfd;
                pthraed_create(&thread，NULL，worker，(void *)&fds_for_new_worker);
                
            }
            else
            {
                printf("someting else happened\n");
            }
        }
    }
}

三个I/O函数的对比：

select和poll都只能工作在较低的LT模式，而epoll可以在ET模式。select和poll采用的是轮询的模式，每次调用都要扫描整个注册文件的描述符集合，将其中的就绪文件描述符给用户，检测时间复杂度为O(n)；epoll_wait是回调的方式，O(1)；