五种I/O模型与高级I/O-优快云博客

一.5种I/O模型

一个I/O可以分为两个过程:等待和数据搬迁。

1.阻塞I/O

两个过程都有自己来完成，其他什么事也不做。

2.非阻塞I/O

在等的过程中可以干一些其他的事，等到数据准备好再进行搬迁

3.信号驱动I/O

等数据准备好的过程由信号来触发，在这期间自己可以干一些别的事

4.I/O复用

同时阻塞多个I/O操作，谁数据准备好就对其进行数据搬迁。

5.异步I/O

将任务派发，不用自己来完成。完成之后通知自己就行。

二.高级I/O

非阻塞IO，纪录锁，系统V流机制，I/O多路转接（select/poll）,readv和writev函数以及存储映射IO（mmap），这些统称为高级IO。

1.socketpair

pipe用来创建管道，但是单个管道只能单向通信，一端用于读，而另一端用于写。如果要实现进程双向通信，必须创建一对管道。而socketpair则可以用来创建双向通信的管道，具体实现如下：

#include <sys/types.h> /* See NOTES */

#include <sys/socket.h>

int socketpair(int domain, int type, int protocol, int sv[2]);

domain：域 type：传输类型 protocol：协议类型，

创建父子进程，让子进程关闭读，父关闭写，然后双方发送消息

  1 #include<stdio.h>
  2 #include<errno.h>
  3 #include<unistd.h>
  4 #include<stdlib.h>
  5 #include<string.h>
  6 #include<sys/socket.h>
  7 #include<sys/types.h>
  8 int main()
  9 {
 10    int sv[2]={0,0};
 11    int sock=socketpair(AF_LOCAL,SOCK_STREAM,0,sv);
 12    if(sock<0)
 13    {
 14       perror("socketpair");
 15       exit(1);
 16    }
 17    pid_t id=fork();
 19    if(id<0)
 20    {
 21      perror("fork");
 22      exit(2);
 23    }
 24    else if(id==0)
 25   {
 26    close (sv[0]);//读关闭
 27    char buf[1024];
 28    while(1)
 29    {
 30      memset(buf,'\0',sizeof(buf));
 31      strcpy(buf,"hello bit");
 32      write(sv[1],buf,sizeof(buf)-1);
 33      ssize_t size=read(sv[1],buf,sizeof(buf)-1);
 34      buf[size]='\0';
 36     sleep(1);
 37 
 38      printf("father->child:  %s\n",buf);
 39    }
 40   }
 41  else
 42   {
 43      close (sv[1]);//写关闭
 44      char buf[1024];
 45      while(1)
 46      {
 47        ssize_t size=read(sv[0],buf,sizeof(buf)-1);
 48        buf[size]='\0';
 49        printf("child-> father: %s\n",buf);
 50        strcpy(buf,"hello");
 51        write(sv[0],buf,sizeof(buf));
 52           //sleep(2);
 53      }
 54    }
 55 
 56    return 0;
 57 }

程序结果：

2.dup/dup2对输入文件描述符重定向

dup将标准输出重定向当前旧的且不用的最小文件描述符。

dup2将old文件描述符指向的内容复制到new，两者指向同一文件

dup代码：

  1 #include<stdio.h>
  2 //#define _OPEN_FILE_ "./log"
  3 #include<unistd.h>
  4 #include<sys/types.h>
  5 #include<fcntl.h>
  6 #include<sys/stat.h>
  7 #include<unistd.h>
  8 int main()
  9 {
 10    umask(0);
 11    int fd=open("./log",O_CREAT|O_RDWR);
 12    if(fd<0)
 13    {
 14       printf("open");
 15       exit(1);
 16       
 17    }  
 18    close(1);
 19    int new_fd=dup(fd）;
 20    close(fd);
 23     int count=1;
 24    while(count++<10)
 25   {
 26 
 27       printf("hello bit\n");
 28       fflush(stdout);
 29   }
 31   close(new_fd);
 33   return 0;
 34 }

程序结果:

dup2代码：

 8 int main()
  9 {
 10    umask(0);
 11    int fd=open("./log",O_CREAT|O_RDWR);
 12    if(fd<0)
 13    {
 14       printf("open");
 15       exit(1);
 16       
 17    }  
 18    close(1);
 19    int ret=dup2(fd,1）;
 20    
 23     int count=1;
 24    while(count++<10)
 25   {
 26 
 27       printf("hello bit\n");
 28       fflush(stdout);
 29   }
 31   close(fd);
 33   return 0;
 34 }

3.I/O多路转接之select

系统提供select函数来实现多路复用输入/输出模型。select系统调用来让我们的程序监视

个句柄的状态变化，0是标准输入，1是标准输出，2是标准错误输出。0、1、2是整数表示的，对应的FILE *结构的表示就是stdin、stdout、stderr。

#include <sys/time.h>

#include <sys/types.h>

#include <unistd.h>

int select(int nfds, fd_set *readfds, fd_set *writefds,

fd_set *exceptfds, struct timeval *timeout);

参数nfds是需要监视的最大的文件描述符值+1；

rdset,wrset,exset分别对应于需要检测的可读文件描述符的集合，可写文件描述符的集合及异常文件描述符的集合。

struct timeval结构用于描述一段时间长度，如果在这个时间内，需要监视的描述符没有事件发生则函数返回，返回值为0。

下面的宏提供了处理这三种描述词组的方式:

FD_CLR(inr fd,fd_set* set)；用来清除描述词组set中相关fd 的位

FD_ISSET(int fd,fd_set *set)；用来测试描述词组set中相关fd 的位是否为真

FD_SET（int fd,fd_set*set）；用来设置描述词组set中相关fd的位

FD_ZERO（fd_set *set）；用来清除描述词组set的全部位

参数timeout为结构timeval，用来设置select()的等待时间，其结构定义如下：

wKioL1dG-5biAxNxAAA0ezQljTk743.png-wh_50

如果参数timeout设为：

NULL：则表示select（）没有timeout，select将一直被阻塞，直到某个文件描述符上发生了

事件。

0：仅检测描述符集合的状态，然后立即返回，并不等待外部事件的发生。

特定的时间值：如果在指定的时间段里没有事件发生，select将超时返回。

理解select模型：

理解select模型的关键在于理解fd_set,为说明方便，取fd_set长度为1字节，fd_set中的每一bit可以对应一个文件描述符fd。则1字节长的fd_set最大可以对应8个fd。

（1）执行fd_set set; FD_ZERO(&set);则set用位表示是0000,0000。

（2）若fd＝5,执行FD_SET(fd,&set);后set变为0001,0000(第5位置为1)

（3）若再加入fd＝2，fd=1,则set变为0001,0011

（4）执行select(6,&set,0,0,0)阻塞等待

（5）若fd=1,fd=2上都发生可读事件，则select返回，此时set变为0000,0011。注意：没有事件发生的fd=5被清空。

　基于上面的讨论，可以轻松得出select模型的特点：

　　（1)可监控的文件描述符个数取决与sizeof(fd_set)的值。我这边服务器上sizeof(fd_set)＝512，每bit表示一个文件描述符，则我服务器上支持的最大文件描述符是512*8=4096。据说可调，另有说虽然可调，但调整上限受于编译内核时的变量值。

　　（2）将fd加入select监控集的同时，还要再使用一个数据结构array保存放到select监控集中的fd，一是用于再select 返回后，array作为源数据和fd_set进行FD_ISSET判断。二是select返回后会把以前加入的但并无事件发生的fd清空，则每次开始 select前都要重新从array取得fd逐一加入（FD_ZERO最先），扫描array的同时取得fd最大值maxfd，用于select的第一个参数。

　　（3）可见select模型必须在select前循环array（加fd，取maxfd），select返回后循环array

（FD_ISSET判断是否有时间发生）。

1>select使用事例，检测标准输入输出代码：

1 #include<stdio.h>>
  2 #include<unistd.h>
  3 #include<errno.h>
  4 #include<stdlib.h>
  5 #include<string.h>
  6 #include<sys/select.h>
  7 
  8 int main()
  9 {
 10    int std_in=0;//标准输入
 11    //int std_out=1;//标准输出
 12    int max_fd=0;
 13    struct timeval timeout={2,0};//超时
 14    fd_set reads;//定义文件描述符集
 15    //fd_set writes;
 16    FD_ZERO(&reads); //初始化 
 17    //FD_ZERO(&writes);   
 18    FD_SET(std_in,&reads);//站在应用程序的角度来看关心什么事件
 19    //FD_SET(std_out,&writes);
 20     while(1)
 21     {
 22       timeout.tv_sec=2;
 23       timeout.tv_usec=0;
 24       FD_ZERO(&reads); //重新设置 
 25      // FD_ZERO(&writes);   
 26       FD_SET(std_in,&reads);
 27       //FD_SET(std_out,&writes);
 28      switch(select((max_fd+1),&reads,NULL,NULL,&timeout))
 29      {
 30        case -1://biaoshichucuo
 31          perror("select");
 32          break;
 33        case 0://chaoshi
 34          printf("select timeout....\n");
 35          break;
 36        default://zhengchang
 37         {//panduanshuijiuxu
 38           if(FD_ISSET(std_in,&reads))
 39            {
 40               char buf[1024];
 41               memset(buf,'\0',sizeof(buf));
 42               ssize_t size=read(std_in,buf,strlen(buf));
 43               if(size>0)//duquchenggong
 44                {
 45                   buf[size]='\0';
 46                   printf("%s\n",buf);
 47                }
 48             }
 49            // if(FD_ISSET(std_out,&writes))
 50             //{
 51               //   printf("hello\n");
 52 
 53            // }
 54          }
 55         break;
 56 
 57      }
 58     }
 59     return 0;
 60 }

程序中剥离write的事件，程序结果会打印过上timeout时间之后打印select timeout，

若将write放开，则会一直打印消息。因为写一直就绪。

2>select使用事例select编写网络服务器代码

 //select_server.c
 
  1 #include<stdio.h>
  2 #include<sys/select.h>
  3 #include<sys/socket.h>
  4 #include<errno.h>
  5 #include<string.h>
  6 #include<arpa/inet.h>
  7 #include<netinet/in.h>
  8 #include<stdlib.h>
  9 #include<sys/types.h>
 10 int fds[64];//yongshuzubaocunwenjianmaioshufuji
 11 static void usage(char* proc)
 12  {
 13     printf("usage: %s [ip] [port]",proc);
 14  }
 15 
 16 static int start(int port,char *ip)
 17 {
 18      int sock=socket(AF_INET,SOCK_STREAM,0);
 19      if(sock<0)
 20        {
 21          perror("socket");
 22          exit(1);
 23        }
 24       struct sockaddr_in local;
 25       local.sin_family=AF_INET;
 26       local.sin_port=htons(port);
 27       local.sin_addr.s_addr=inet_addr(ip);
 28      if(bind(sock,(struct sockaddr*)&local,sizeof(local))<0)
 29      {
 30          perror("bind");
 31          exit(1);
 32      }
 33     if(listen(sock,5)<0)
 34      {
 35         perror("listen");
 36         exit(1);
 37       }
 38     return sock;
 39 
 40 
 41 }
 42  int main(int argc,char*argv[])
 43 {
 44     if(argc!=3) 
 45       {
 46         usage(argv[0]);
 47         return 1;
 48        }
 49      int port=atoi(argv[2]);
 50      char* ip=argv[1];
 51      int listen_sock=start(port,ip);
 52      int new_sock=-1;
 53      struct sockaddr_in client;
 54      socklen_t len=sizeof(client);
 55      int max_fd=0;
 56      fd_set reads;//dingyiwenjianmiaoshufuji
 57      fd_set writes;
 58      FD_ZERO(&reads);
 59      FD_ZERO(&writes);
 60      FD_SET(listen_sock,&reads);
 61     struct timeval timeout={15,0};
 62     int fds_num=sizeof(fds)/sizeof(fds[0]);
 63     int i=0;
 64     for(;i<fds_num;++i)
 65        {
 66          fds[i]=-1;
 67        }
 68       fds[0]=listen_sock;
 69       max_fd=fds[0];
 70    while(1)
 71     {
 72       timeout.tv_sec=15;
 73       timeout.tv_usec=0;
 74       FD_ZERO(&reads);
 75       FD_ZERO(&writes);
 76       FD_SET(listen_sock,&reads);
 77 
 78      for(i=1;i<fds_num;++i)
 79       {
 80         if(fds[i]>0)
 81          {
 82             FD_SET(fds[i],&reads);
 83             if(fds[i]>max_fd)
 84               {
 85                max_fd=fds[i];
 86                }
 87           }
 88        }
 89       switch(select(max_fd+1,&reads,NULL,NULL,&timeout))
 90       {
 91          case -1:// 出错
 92           perror("select");
 93           break;
 94          case 0://超时
 95          printf("select timeout......\n");
 96          break;
 97          default://正常
 98           {
 99             for(i=0;i<fds_num;++i)
100              {//当为listen_sock
101                if(fds[i]==listen_sock&&FD_ISSET(fds[i],&reads))
102                  { //接收连接请求
103                     new_sock=accept(listen_sock,(struct sockaddr*)&client,&l    en);
104                    if(new_sock<0)
105                      {
106                        perror("accept");
107                        continue;
108                       }
109                      printf("get connect........\n");
110                     for(i=0;i<fds_num;++i)
111                       {
112                          if(fds[i]==-1)
113                             {
114                                fds[i]=new_sock;
115                                break;
116                              }
117                        }
118                       if(i==fds_num)
119                         {
120                           close(new_sock);
121                         }
122                   }
                       //break
123                   else if(fds[i]>0&&FD_ISSET(fds[i],&reads))
124                     {
125                        char buf[1024];
126                        memset(buf,'\0',sizeof(buf));
127                        ssize_t size=read(fds[i],buf,sizeof(buf)-1);
128                        if(size>0)
129                        {
130                           buf[size]='\0';
131                           printf("client#: %s",buf);
132                           write(fds[i],buf,size);
133                        }
134                         else if(size==0)
135                          {
136                            close(fds[i]);
137                            fds[i]=-1;//取到文件描述符将其置为无效
138 
139                           }
140                       }
141                }
142            }
143             break;
144 
145          }
146   }
147    return 0;
148 }

//select_client.c
  1 #include<stdio.h>
  2 #include<sys/select.h>
  3 #include<sys/socket.h>
  4 #include<errno.h>
  5 #include<string.h>
  6 #include<arpa/inet.h>
  7 #include<netinet/in.h>
  8 #include<sys/types.h>
  9 #include<stdlib.h>
 10 
 11 //int fds[64];//yongshuzubaocunwenjianmaioshufuji
 12 static void usage(char* proc)
 13  {
 14     printf("usage: %s [ip] [port]",proc);
 15  }
 16 
 17 int main(int argc,char *argv[])
 18 {
 19  if(argc!=3)
 20       {
 21         usage(argv[0]);
 22         return 1;
 23        }
 24      int port=atoi(argv[2]);
 25      char* ip=argv[1];
 26     int sock=socket(AF_INET,SOCK_STREAM,0);
 27      if(sock<0)
 28       {
 29         perror("socket");
 30          exit(1);
 31        }
 32       struct sockaddr_in remote;
 33       remote.sin_family=AF_INET;
 34       remote.sin_port=htons(port);
 35       remote.sin_addr.s_addr=inet_addr(ip);
 36   int ret=connect(sock,(struct sockaddr*)&remote,sizeof(remote));
 37   if(ret<0)
 38   {
 39       perror("connect");
 40       exit(2);
 41   }
 42    char buf[1024];
 43  while(1)
 44  {
 45    memset(buf,'\0',sizeof(buf));
 46    printf("please input: ");
 47    fflush(stdout);
 48    ssize_t s=read(0,buf,sizeof(buf)-1);
 49 
 50  if(s>0)
 51  { //回显消息
 52    write(sock,buf,strlen(buf));
 53    printf("server->client: %s\n",buf);
 54   }
 55   }
 56 
 57   return 0;
 58 }

程序结果：