7.3 5种IO模型与IO复用

　　5种IO模型分别如下：

1、阻塞IO模型

当上层应用app1调用recv系统调用时，如果对等方没有发送数据（缓冲区没有数据），上层app1将阻塞（默认行为，被linux内核阻塞）。

当对等方发送了数据，linux内核recv端缓冲区有数据后，内核会把数据copy给用户空间。然后上层应用app1解除阻塞，执行下一步操作。

2、非阻塞IO模型

上层应用程序app2将套接字设置成非阻塞模式。

上层应用程序app2轮询调用recv函数，接收数据，若缓冲区没有数据，上层程序app2不会阻塞，recv返回值-1，错误码是EWOULDBLOCK。

上层应用程序不断轮询有没有数据到来，会造成上层应用忙等待，大量的消耗CPU时间，很少直接用，应用范围小，一般和select IO复用配合使用。

阻塞IO和非阻塞IO是两个极端，一个是没有数据就死等，另一个极端是轮询。

有没有这样一种机制去管理n个文件描述符，当文件描述符状态发生变化了，会通知应用程序呢？这就是IO复用技术，也叫作多路复用。

3、IO复用模型

上层应用程序app3调用select机制（该机制由linux内核支持，避免了app3忙等待），进行轮询文件描述符的状态变化。

当select管理的文件描述符没有数据（或者状态没有变化时），上层应用程序app3也会阻塞。

好处是select会管理多个文件描述符。

select可以看成一个管理者，用select来管理多个IO。

一旦检测到一个IO或者多个IO有我们感兴趣的事件发生，select函数将返回，返回值为检测到的事件个数，继而可以利用select相关api函数，具体操作事件。

select函数可以设置等待时间，避免了上层应用程序app3长期僵死。

和阻塞IO模型相比，select IO复用模型相当于提前阻塞了，等到有数据到来时再调用recv就不会发生阻塞。

4、信号驱动模型：

上层应用程序app4建立SIGIO信号处理程序，当缓冲区有数据到来时，内核会发送信号告诉上层应用程序app4。

上层应用程序app4接收到信号后，调用recv函数，因缓冲区有数据，recv函数一般不会阻塞。

这种模型用的也比较少，属于典型的“拉模式”，即上层应用程序app4需要调用recv函数把数据拉进来。

应用程序接收到信号有一个时间延迟，处理这个信号可能还有一个时间延迟，如果这些延迟比较长，内核空间数据有可能发生变化。存在隐患。因此，这种IO模型用的不多。

5、异步IO模型

上层应用app5调用aio_read函数，同时提交一个应用层的缓冲区buf，调用完毕后不会阻塞，上层应用程序app5可以进行其他任务。

当TCP IP协议缓冲区有数据时，linux内核主动把内核缓冲区中的数据copy到用户空间，然后再给上层应用app5发送信号，告诉app5数据有了，赶快处理吧。

这是典型的推模式。

效率最高的一种形式，上层应用app5有异步处理的能力（在linux内核的支持下，言外之意：处理其他任务的同时，也可支持IO通讯）。

上层应用app5也可以在干别的活儿的同时接收数据。与信号驱动IO模型相比，上层应用程序app5不需要调用recv函数。

这种IO模型效率非常高，是高性能、高并发服务器常用的模型。

IO复用模型和异步IO模型是两种常用的模型。

重要概念：

阻塞IO：

　　数据没有准备好，读操作就会阻塞。

　　数据不能立即被收时，写操作就会阻塞。

　　打开文件时阻塞，直到某些条件发生。

非阻塞IO：

　　立即返回，并用错误值来表示当前的状态。

指定非阻塞方式：

　　打开时指定O_NONBLOCK标志。

　　使用fcntl打开或者关闭非阻塞方式

网络编程时，使用非阻塞，用轮询方式发送

使用多线程可以避免使用非阻塞IO，但是同步开销大

多路IO：

　　当程序需要同时从两个输入读数据时

　　使用多进程、多线程，同步复杂，进程线程开销

　　使用非阻塞IO，交替轮询

　　通过信号使用异步IO，无法判断哪个IO完成

　　多路IO：把关心的IO放入一个列表，调用多路函数

　　多路IO函数阻塞，直到有一个数据准备好后返回

　　返回后告诉调用者哪个描述符准备好了

IO复用模型分析：

　　select实现说明：

　　　　调用select时通过参数告诉内核用户感兴趣的IO描述符

　　　　关心的IO状态：输入、输出或者错误

　　　　调用者等待时间

　　　　返回之后内核告诉调用者多个描述符准备好了

　　　　哪些描述符发生了变化

　　　　调用返回后对准备好的描述符调用读写操作

　　　　不关心的描述符集传NULL

select函数原型如下：

int select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);

监视readfs来查看是否read的时候会被阻塞，注意：即使到了end-of-file，fd也是可读的

监视writefds看写的时候会不会阻塞

监视excepted是否出现了异常，主要用来读取OOB数据，异常并不是指出错

注意当一个套接口出错时，它会变得既可读又可写

如果有了状态改变，会将其他fd清零，只有那些发生改变了的fd保持置位，以用来指示set中的哪一个改变了状态

参数n是所有set里的所有fd里面，具有最大值的那个fd的值加1

以下四个宏用来对fd_set进行操作：

void FD_CLR(int fd, fd_set *set); ：把一个描述符从集合内移除
int FD_ISSET(int fd, fd_set *set) ：测试某个描述符是否在集合内
void FD_SET(int fd, fd_set *set) ：　把一个描述符加入集合

void FD_ZERO(fd_set *set) ：清空描述符集合

每个描述符在集合中只占一位，如下所示：

下面我们将客户端程序改成select形式，select用来监视标准输入描述符和套接字，服务器端程序还是用普通的多进程模型。只给出客户端程序如下：

 #include <sys/types.h>
 #include <unistd.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <errno.h>
 #include <signal.h>
 #include <arpa/inet.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <sys/socket.h>
 #include <netinet/ip.h> /* superset of previous */

 void handler(int num)
 {
     printf("signal num : %d\n", num);
 }

 ssize_t readn(int fd, void *buf, size_t count)
 {
     size_t nleft = count;
     ssize_t nread;

     char *bufp = (char*)buf;

     while(nleft > )
     {
         if( (nread = read(fd, bufp, nleft)) <  )
         {
             if(errno == EINTR)
             {
                 continue;
             }

             return -;
         }
         else if(nread == )
         {
             return count - nleft;
         }

         bufp += nread;
         nleft -= nread;
     }

     return count;
 }

 ssize_t writen(int fd, const void *buf, size_t count)
 {
     size_t nleft = count;
     ssize_t nwritten;

     char *bufp = (char*)buf;

     while(nleft > )
     {
         if( (nwritten = write(fd, bufp, nleft)) < )
         {
             if(errno == EINTR)
             {
                 continue;
             }

             return -;
         }
         else if(nwritten == )
         {
             continue;
         }

         bufp += nwritten;
         nleft -= nwritten;
     }

     return count;
 }

 ssize_t recv_peek(int sockfd, void *buf, size_t len)
 {
     while()
     {
         int ret = recv(sockfd, buf, len, MSG_PEEK);
         if(ret == - && errno == EINTR)
             continue;
         return ret;
     }
 }

 ssize_t readline(int sockfd, void *buf, size_t maxline)
 {
     int ret;
     int nread;
     char *bufp = (char*)buf;
     int nleft = maxline;

     while()
     {
         ret = recv_peek(sockfd, bufp, nleft);
         if(ret < )
         {
             return ret;
         }
         else if(ret == )
         {
             return ret;
         }

         nread = ret;
         int i;
         for(i = ; i < nread; i++)
         {
             if(bufp[i] == '\n')
             {
                 ret = readn(sockfd, bufp, i+);
                 if(ret != i+)
                 {
                     perror("readn error");
                     exit();
                 }

                 return ret;
             }
         }

         if(nread > nleft)
         {
             perror("FAILURE");
             exit();
         }

         nleft -= nread;
         ret = readn(sockfd, bufp, nread);
         if(ret != nread)
         {
             perror("readn error");
             exit();
         }
         bufp += nread;
     }

     return -;
 }

 void echo_cli(int sock)
 {
     fd_set rset;
     FD_ZERO(&rset);

     int nready;
     int maxfd;
     int fd_stdin = fileno(stdin);
     if(fd_stdin > sock)
         maxfd = fd_stdin;
     else
         maxfd = sock;

     char sendbuf[] = {};
     char recvbuf[] = {};

     int stdineof = ;

     while()
     {
         if (stdineof == )
             FD_SET(fd_stdin, &rset);
         FD_SET(sock, &rset);

         nready = select(maxfd + , &rset, NULL, NULL, NULL);

         if(nready == -)
         {
             perror("select error");
             exit();
         }

         if(nready == )
         {
             continue;
         }

         if(FD_ISSET(sock, &rset))
         {
             int ret = readline(sock, recvbuf, sizeof(recvbuf));
             if(ret == -)
             {
                 perror("readline error");
                 exit();
             }
             else if(ret == )
             {
                 printf("server closed\n");
                 break;
             }

             fputs(recvbuf, stdout);
             memset(recvbuf, , sizeof(recvbuf));
         }

         if(FD_ISSET(fd_stdin, &rset))
         {
             if(fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
             {
                 printf("ctrl+d result fgets return\n");
                 stdineof = ;
                 close(sock);
             }
             else
             {
                 writen(sock, sendbuf, strlen(sendbuf));
                 memset(sendbuf, , sizeof(sendbuf));
             }
         }

     }
 }

 int main()
 {
     int sockfd;

     signal(SIGPIPE, handler);

     sockfd = socket(AF_INET, SOCK_STREAM, );

     struct sockaddr_in addr;
     addr.sin_family = AF_INET;
     addr.sin_port = htons();
     inet_aton("192.168.31.128", &addr.sin_addr);
     //addr.sin_addr.s_addr = inet_addr("192.168.31.128");

     if( connect(sockfd, (struct sockaddr *)&addr, sizeof(addr)) == - )
     {
         perror("connect error");
         exit();
     }

     struct sockaddr_in localaddr;
     socklen_t addrlen = sizeof(localaddr);
     if(getsockname(sockfd, (struct sockaddr*)&localaddr, &addrlen) < )
     {
         perror("getsockname error");
         exit();
     }

     printf("ip=%s  port=%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));

     echo_cli(sockfd);

     return ;
 }

核心函数为echo_cli，其中调用了select函数，167、168将两个描述符加入到监视器中。fgets发生错误或者读到文件末尾时会返回NULL。读标准输入时ctrl+d代表文件末尾。

启动服务器和客户端，执行结果如下：

connect连接时，会阻塞进程，在公网上默认会等待75秒超时，但是一般应用不想等这么久，因此，需要优化一下。

网络模型中常用的操作：

 #ifndef _SCK_UTIL_H_
 #define _SCK_UTIL_H_

 #include <unistd.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <sys/select.h>
 #include <sys/time.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <netdb.h>

 #include <stdio.h>
 #include <errno.h>
 #include <string.h>
 #include <stdlib.h>

 #define ERR_EXIT(m) \
   do \
   { \
     perror(m); \
     exit(EXIT_FAILURE); \
   } \
   while ()

 void activate_nonblock(int fd);
 void deactivate_nonblock(int fd);

 int read_timeout(int fd, unsigned int wait_seconds);
 int write_timeout(int fd, unsigned int wait_seconds);
 int accept_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds);
 int connect_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds);

 ssize_t readn(int fd, void *buf, size_t count);
 ssize_t writen(int fd, const void *buf, size_t count);
 ssize_t recv_peek(int sockfd, void *buf, size_t len);
 ssize_t readline(int sockfd, void *buf, size_t maxline);

 #endif /* _SYS_UTIL_H_ */

 #include "sckutil.h"

 /* read函数的调用方法
 int ret;
 ret = read_timeout(fd, 5);
 if (ret == 0)
 {
     read(fd, ...);
 }
 else if (ret == -1 && errno == ETIMEDOUT)
 {
     timeout....
 }
 else
 {
     ERR_EXIT("read_timeout");
 }
 */

 /**
  * read_timeout - 读超时检测函数，不含读操作
  * @fd: 文件描述符
  * @wait_seconds: 等待超时秒数，如果为0表示不检测超时
  * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
  */
 int read_timeout(int fd, unsigned int wait_seconds)
 {
     int ret = ;
     if (wait_seconds > )
     {
         fd_set read_fdset;
         struct timeval timeout;

         FD_ZERO(&read_fdset);
         FD_SET(fd, &read_fdset);

         timeout.tv_sec = wait_seconds;
         timeout.tv_usec = ;

         //select返回值三态
         //1 若timeout时间到（超时），没有检测到读事件 ret返回=0
         //2 若ret返回<0 &&  errno == EINTR 说明select的过程中被别的信号中断（可中断睡眠原理）
         //2-1 若返回-1，select出错
         //3 若ret返回值>0 表示有read事件发生，返回事件发生的个数

         do
         {
             ret = select(fd + , &read_fdset, NULL, NULL, &timeout);
         } while (ret <  && errno == EINTR);

         if (ret == )
         {
             ret = -;
             errno = ETIMEDOUT;
         }
         else if (ret == )
             ret = ;
     }

     return ret;
 }

 /**
  * write_timeout - 写超时检测函数，不含写操作
  * @fd: 文件描述符
  * @wait_seconds: 等待超时秒数，如果为0表示不检测超时
  * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
  */
 int write_timeout(int fd, unsigned int wait_seconds)
 {
     int ret = ;
     if (wait_seconds > )
     {
         fd_set write_fdset;
         struct timeval timeout;

         FD_ZERO(&write_fdset);
         FD_SET(fd, &write_fdset);

         timeout.tv_sec = wait_seconds;
         timeout.tv_usec = ;
         do
         {
             ret = select(fd + , NULL, &write_fdset, NULL, &timeout);
         } while (ret <  && errno == EINTR);

         if (ret == )
         {
             ret = -;
             errno = ETIMEDOUT;
         }
         else if (ret == )
             ret = ;
     }

     return ret;
 }

 /**
  * accept_timeout - 带超时的accept
  * @fd: 套接字
  * @addr: 输出参数，返回对方地址
  * @wait_seconds: 等待超时秒数，如果为0表示正常模式
  * 成功（未超时）返回已连接套接字，超时返回-1并且errno = ETIMEDOUT
  */
 int accept_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds)
 {
     int ret;
     socklen_t addrlen = sizeof(struct sockaddr_in);

     if (wait_seconds > )
     {
         fd_set accept_fdset;
         struct timeval timeout;
         FD_ZERO(&accept_fdset);
         FD_SET(fd, &accept_fdset);
         timeout.tv_sec = wait_seconds;
         timeout.tv_usec = ;
         do
         {
             ret = select(fd + , &accept_fdset, NULL, NULL, &timeout);
         } while (ret <  && errno == EINTR);
         if (ret == -)
             return -;
         else if (ret == )
         {
             errno = ETIMEDOUT;
             return -;
         }
     }

     //一但检测出 有select事件发生，表示对等方完成了三次握手，客户端有新连接建立
     //此时再调用accept将不会堵塞
     if (addr != NULL)
         ret = accept(fd, (struct sockaddr*)addr, &addrlen); //返回已连接套接字
     else
         ret = accept(fd, NULL, NULL);
     if (ret == -)
         ERR_EXIT("accept");

     return ret;
 }

 /**
  * activate_noblock - 设置I/O为非阻塞模式
  * @fd: 文件描符符
  */
 void activate_nonblock(int fd)
 {
     int ret;
     int flags = fcntl(fd, F_GETFL);
     if (flags == -)
         ERR_EXIT("fcntl");

     flags |= O_NONBLOCK;
     ret = fcntl(fd, F_SETFL, flags);
     if (ret == -)
         ERR_EXIT("fcntl");
 }

 /**
  * deactivate_nonblock - 设置I/O为阻塞模式
  * @fd: 文件描符符
  */
 void deactivate_nonblock(int fd)
 {
     int ret;
     int flags = fcntl(fd, F_GETFL);
     if (flags == -)
         ERR_EXIT("fcntl");

     flags &= ~O_NONBLOCK;
     ret = fcntl(fd, F_SETFL, flags);
     if (ret == -)
         ERR_EXIT("fcntl");
 }

 /**
  * connect_timeout - connect
  * @fd: 套接字
  * @addr: 要连接的对方地址
  * @wait_seconds: 等待超时秒数，如果为0表示正常模式
  * 成功（未超时）返回0，失败返回-1，超时返回-1并且errno = ETIMEDOUT
  */
 int connect_timeout(int fd, struct sockaddr_in *addr, unsigned int wait_seconds)
 {
     int ret;
     socklen_t addrlen = sizeof(struct sockaddr_in);

     if (wait_seconds > )
         activate_nonblock(fd);

     ret = connect(fd, (struct sockaddr*)addr, addrlen);
     if (ret <  && errno == EINPROGRESS)
     {
         //printf("11111111111111111111\n");
         fd_set connect_fdset;
         struct timeval timeout;
         FD_ZERO(&connect_fdset);
         FD_SET(fd, &connect_fdset);
         timeout.tv_sec = wait_seconds;
         timeout.tv_usec = ;
         do
         {
             // 一但连接建立，则套接字就可写  所以connect_fdset放在了写集合中
             ret = select(fd + , NULL, &connect_fdset, NULL, &timeout);
         } while (ret <  && errno == EINTR);
         if (ret == )
         {
             ret = -;
             errno = ETIMEDOUT;
         }
         else if (ret < )
             return -;
         else if (ret == )
         {
             //printf("22222222222222222\n");
             /* ret返回为1（表示套接字可写），可能有两种情况，一种是连接建立成功，一种是套接字产生错误，*/
             /* 此时错误信息不会保存至errno变量中，因此，需要调用getsockopt来获取。 */
             int err;
             socklen_t socklen = sizeof(err);
             int sockoptret = getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &socklen);
             if (sockoptret == -)
             {
                 return -;
             }
             if (err == )
             {
                 //printf("3333333333333\n");
                 ret = ;
             }
             else
             {
                 //printf("4444444444444444:%d\n", err);
                 errno = err;
                 ret = -;
             }
         }
     }
     if (wait_seconds > )
     {
         deactivate_nonblock(fd);
     }
     return ret;
 }

 /**
  * readn - 读取固定字节数
  * @fd: 文件描述符
  * @buf: 接收缓冲区
  * @count: 要读取的字节数
  * 成功返回count，失败返回-1，读到EOF返回<count
  */
 ssize_t readn(int fd, void *buf, size_t count)
 {
     size_t nleft = count;
     ssize_t nread;
     char *bufp = (char*)buf;

     while (nleft > )
     {
         if ((nread = read(fd, bufp, nleft)) < )
         {
             if (errno == EINTR)
                 continue;
             return -;
         }
         else if (nread == )
             return count - nleft;

         bufp += nread;
         nleft -= nread;
     }

     return count;
 }

 /**
  * writen - 发送固定字节数
  * @fd: 文件描述符
  * @buf: 发送缓冲区
  * @count: 要读取的字节数
  * 成功返回count，失败返回-1
  */
 ssize_t writen(int fd, const void *buf, size_t count)
 {
     size_t nleft = count;
     ssize_t nwritten;
     char *bufp = (char*)buf;

     while (nleft > )
     {
         if ((nwritten = write(fd, bufp, nleft)) < )
         {
             if (errno == EINTR)
                 continue;
             return -;
         }
         else if (nwritten == )
             continue;

         bufp += nwritten;
         nleft -= nwritten;
     }

     return count;
 }

 /**
  * recv_peek - 仅仅查看套接字缓冲区数据，但不移除数据
  * @sockfd: 套接字
  * @buf: 接收缓冲区
  * @len: 长度
  * 成功返回>=0，失败返回-1
  */
 ssize_t recv_peek(int sockfd, void *buf, size_t len)
 {
     while ()
     {
         int ret = recv(sockfd, buf, len, MSG_PEEK);
         if (ret == - && errno == EINTR)
             continue;
         return ret;
     }
 }

 /**
  * readline - 按行读取数据
  * @sockfd: 套接字
  * @buf: 接收缓冲区
  * @maxline: 每行最大长度
  * 成功返回>=0，失败返回-1
  */
 ssize_t readline(int sockfd, void *buf, size_t maxline)
 {
     int ret;
     int nread;
     char *bufp = buf;
     int nleft = maxline;
     while ()
     {
         ret = recv_peek(sockfd, bufp, nleft);
         if (ret < )
             return ret;
         else if (ret == )
             return ret;

         nread = ret;
         int i;
         for (i=; i<nread; i++)
         {
             if (bufp[i] == '\n')
             {
                 ret = readn(sockfd, bufp, i+);
                 if (ret != i+)
                     exit(EXIT_FAILURE);

                 return ret;
             }
         }

         if (nread > nleft)
             exit(EXIT_FAILURE);

         nleft -= nread;
         ret = readn(sockfd, bufp, nread);
         if (ret != nread)
             exit(EXIT_FAILURE);

         bufp += nread;
     }

     return -;
 }

上述带超时的函数，具有一定的健壮性，将IO设置为阻塞或者非阻塞，主要是给connect_timeout函数用。先将fd设置为非阻塞，这样connect就可以立即返回，如果返回时fd还没有连接好，即errno == EINPROGRESS，则调用select去监控这个fd，要么指定时间内fd可用，要么超时。虽然connect立即返回了，但是三次握手内核还是会做的。fd可读可有两种可能，一种是连接建立了，真正可读了，另一种是发生错误了，这时候fd也可读了。因此，

我们需要调用getsockopt(fd, SOL_SOCKET, SO_ERROR, &err, &socklen)来获取错误码，根据错误码进行进一步的判断。

connect_timeout总结如下图：

优化网络应用就是优化连接，可以通过在客户端建立连接池提供优化。TCP IP三次握手很浪费时间。

select三个应用场景：

1、用select封装超时（connect、accept、read、write）

2、用select优化客户端（stdin、confd）

3、用select优化服务器（用一个单进程去支持多个客户端）

select是一个管理机制，管理了多个IO，用单进程轮询的方式去查询n个IO是否发生了变化。