网络编程-五种i/o模型及select模型

五种i/o模型

首先是认识几个概念：

同步通信 & 异步通信
同步通信与异步通信关注的是消息通信机制（与进程/线程同步概念完全不相关）

• 同步通信：指在发出一个调用时，在得到结果之前，该调用就不返回。但是一旦调用返回，就得到返回值了。可以说是，由调用者主动等待这个调用的结果。
• 异步通信则是相反，调用在发出之后，该调用立刻就返回了，所以是没有返回结果的。换句话说，当调用发出后，调用者不会立刻得到结果，而是在调用发出后，被调用者通过状态，通知来通知调用者，或通过回调来处理该调用。

阻塞 & 非阻塞
阻塞和非阻塞关注的是程序在等待调用结果时的状态。

• 阻塞：在调用结果返回之前，当前线程会被挂起，调用线程只有在得到结果之后才会返回。
• 非阻塞：在不能立刻得到返回结果时，该调用不会阻塞调用该线程。

五种i/o模型

阻塞i/o：在内核将数据准备好之前，系统调用会一直等待，所有的套接字，默认都是阻塞方式。

非阻塞i/o：如果内核还未将数据准备好，系统调用仍然会直接返回，并且返回EWOULDBLOCK错误码。非阻塞i/o往往需要程序员循环方式的反复尝试读写文件描述符，这个过程称为轮询，这对cpu来说是较大的浪费，一般只有特定场景下才使用。

信号驱动i/o：在内核将数据准备好的时候，使用SIGIO信号通知应用程序进行i/o操作

i/o多路转换：虽然从流程图上看起来和阻塞i/o类似，实际上最核心在于i/o多路转换能够同时等待多个文件描述符的就绪状态

异步i/o：由内核在数据拷贝完成时，通知应用程序（而信号驱动式告诉应用程序何时可以开始拷贝数据）

总结：任何i/o过程，都包含两个步骤，第一是等待，第二是拷贝。而且在实际的应用场景下，等待消耗的时间往往都远远高于拷贝的时间，让i/o更高效，最核心的方法就是让等待的时间尽量少。

多路转接之select

多路转接可以同时等待多个文件描述符。而select在i/o过程中只做一件事情，就是–等。
等什么？等待事件就绪。
select是系统调用来实现多路复用输入/输出模型

函数原型

• nfds：是需要监视的最大文件描述符+1
• readfds，writefds，exceptfds：分别对应于需要检测的可读文件描述符集合，可写文件描述符集合及异常文件描述符集合。
• 参数timeout：用来设置select的等待时间。

第一个参数限定了文件描述符的区间范围，第二个参数告诉操作系统我关心那些文件描述符上的那些事件。

fd_set

这个结构其实就是一个位图，使用位图中对应的位来表示要监视的文件描述符。并且不能直接对比特位进行操作，必须使相关的函数接口来进行操作。

函数返回值

• 函数执行成功则返回文件描述符状态已改变的位数
• 返回0则代表timeout超时，没有返回

• -1表示发生错误。

  select执行过程

  为了方便解释，取fd_set为一字节，fd_set中的每一位可以对应一个文件描述符fd。则一个字节可以对应8个文件描述符。
  过程如下：

  1. 对fd_set执行FD_ZERO，将比特位全部置0
  2. 若我要关心的文件描述符为1，2，5，那么执行FD_SET将第1，2，5个比特位设置为1。
  3. 执行select阻塞等待
  4. 若fd=1，fd=2都发生可读事件，则select返回，此时fd_set只有第1，2个比特位为1，没有发生就绪事件的第五个比特位会被清空。

  下面来编写一个select服务器实例：

#define MAX sizeof(fd_set)*8
#define INIT -1
static void arrar_init(int arr_FD[],int num)
{
    int i=0;
    for(i=0;i<num;i++)
    {
        arr_FD[i]=INIT;
    }
}
static int arrar_add(int arr_FD[],int num,int fd)
{
    int i=0;
    for(i=0;i<num;i++)
    {
        if(arr_FD[i]==INIT)
        {
            arr_FD[i]=fd;
            return 0;
        }
    }
    return -1;
}
static void arrar_del(int arr_FD[],int num,int index)
{
    if(index<num&&index>0)
    {
        arr_FD[index]=INIT;
    }
}

int set_rfds(int arr_FD[],int num,fd_set*rfds)
{
    int i=0;
    int max_fd=INIT;
    for(i=0;i<num;i++)
    {
        if(arr_FD[i]>INIT)
        {
            FD_SET(arr_FD[i],rfds);

            if(max_fd<arr_FD[i])
            {
                max_fd=arr_FD[i];
            }

        }
    }
    return max_fd;
}

void service(int arr_FD[],int num,fd_set* rfds)
{
    int i=0;
    for(i=0;i<num;i++)
    {
        if(arr_FD[i]>INIT&&FD_ISSET(arr_FD[i],rfds))
        {
            int fd=arr_FD[i];
            if(i==0)//表示是监听套接字
            {
                struct sockaddr_in client;
                socklen_t len=sizeof(client);
                int new_sock=accept(fd,(struct sockaddr*)&client,&len);
                if(new_sock<0)
                {
                    perror("accept");
                    continue;
                }
                printf("get a new connection [%s %d]\n",inet_ntoa(client.sin_addr),ntohs(client.sin_port));
                if(arrar_add(arr_FD,num,new_sock)<0)
                {
                    printf("server is busy!\n");
                    close(new_sock);
                }
            }
            else//表示是常规文件描述符
            {
                char buf[1024]={0};
                ssize_t s=read(fd,&buf,sizeof(buf)-1);
                if(s>0)
                {
                    buf[s]=0;
                    printf("client say# %s\n",buf);
                }
                else if(s==0)
                {
                    close(fd);
                    printf("client quit\n");
                    arrar_del(arr_FD,num,i);
                }
                else
                {
                    perror("read");
                    close(fd);
                    arrar_del(arr_FD,num,i);
                }
            }
        }
    }
}
int StartUp(int port)
{
    int sock=socket(AF_INET,SOCK_STREAM,0);
    if(sock<0)
    {
        perror("socket");
        exit(1);
    }

    int opt=1;
    setsockopt(sock,SOL_SOCKET,SO_REUSEADDR,&opt,sizeof(opt));

    struct sockaddr_in local;
    local.sin_family=AF_INET;
    local.sin_port=htons(port);
    local.sin_addr.s_addr=htonl(INADDR_ANY);

    if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
    {
        perror("bind");
        exit(2);
    }
    if(listen(sock,5)<0)
    {
        perror("listen");
        exit(3);
    }
    return sock;
}
int main(int argc,char* argv[])
{
    //./server 9999
    if(argc!=2)
    {
        printf("Usage:{%s port}\n",argv[0]);
        return 1;
    }
    int listen_sock=StartUp(atoi(argv[1]));
    int arr_FD[MAX];//这里需要一个数组来进行每次重新设置位图中的文件描述符
    arrar_init(arr_FD,MAX);//对位图的初始化
    arrar_add(arr_FD,MAX,listen_sock);//添加至fd_set
    fd_set rfds;
    int max_fd=0;
    for(;;)
    {
        struct timeval timeout={5,0};
        FD_ZERO(&rfds);
        max_fd = set_rfds(arr_FD,MAX,&rfds);
        switch(select(max_fd+1,&rfds,NULL,NULL,&timeout))//只关心读时间
        {
            case 0:
                printf("select timeout.....!\n");
                break;
            case -1:
                perror("select");
                break;
            default:
                service(arr_FD,MAX,&rfds);
                break;
        }
    }
}

测试效果：