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是否发生了变化。