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
", num);
}

ssize_t readn(int fd, void *buf, size_t count)
{
    size_t nleft = count;
    ssize_t nread;
    
    char *bufp = (char*)buf;
    
    while(nleft > 0)
    {
        if( (nread = read(fd, bufp, nleft)) < 0 )
        {
            if(errno == EINTR)
            {
                continue;
            }
            
            return -1;
        }
        else if(nread == 0)
        {
            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 > 0)
    {
        if( (nwritten = write(fd, bufp, nleft)) < 0)
        {
            if(errno == EINTR)
            {
                continue;
            }
            
            return -1;
        }
        else if(nwritten == 0)
        {
            continue;
        }
        
        bufp += nwritten;
        nleft -= nwritten;
    }
    
    return count;
}

ssize_t recv_peek(int sockfd, void *buf, size_t len)
{
    while(1)
    {
        int ret = recv(sockfd, buf, len, MSG_PEEK);
        if(ret == -1 && 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(1)
    {
        ret = recv_peek(sockfd, bufp, nleft);
        if(ret < 0)
        {
            return ret;
        }
        else if(ret == 0)
        {
            return ret;
        }
        
        nread = ret;
        int i;
        for(i = 0; i < nread; i++)
        {
            if(bufp[i] == '
')
            {
                ret = readn(sockfd, bufp, i+1);
                if(ret != i+1)
                {
                    perror("readn error");
                    exit(0);
                }
                
                return ret;
            }
        }
        
        if(nread > nleft)
        {
            perror("FAILURE");
            exit(0);
        }
        
        nleft -= nread;
        ret = readn(sockfd, bufp, nread);
        if(ret != nread)
        {
            perror("readn error");
            exit(0);
        }
        bufp += nread;
    }
    
    return -1;
}


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[1024] = {0};
    char recvbuf[1024] = {0};
    
    int stdineof = 0;
    
    while(1)
    {
        if (stdineof == 0)
            FD_SET(fd_stdin, &rset);
        FD_SET(sock, &rset);
        
        nready = select(maxfd + 1, &rset, NULL, NULL, NULL);
        
        if(nready == -1)
        {
            perror("select error");
            exit(0);
        }
        
        if(nready == 0)
        {
            continue;
        }
        
        if(FD_ISSET(sock, &rset))
        {
            int ret = readline(sock, recvbuf, sizeof(recvbuf));
            if(ret == -1)
            {
                perror("readline error");
                exit(0);
            }
            else if(ret == 0)
            {
                printf("server closed
");
                break;
            }
            
            fputs(recvbuf, stdout);
            memset(recvbuf, 0, sizeof(recvbuf));
        }
        
        if(FD_ISSET(fd_stdin, &rset))
        {
            if(fgets(sendbuf, sizeof(sendbuf), stdin) == NULL)
            {
                printf("ctrl+d result fgets return
");
                stdineof = 1;
                close(sock);
            }
            else
            {
                writen(sock, sendbuf, strlen(sendbuf));
                memset(sendbuf, 0, sizeof(sendbuf));
            }
        }
        
    }
}

int main()
{
    int sockfd;
    
    signal(SIGPIPE, handler);
    
    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    struct sockaddr_in addr;
    addr.sin_family = AF_INET;
    addr.sin_port = htons(8001);
    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)) == -1 )
    {
        perror("connect error");
        exit(0);
    }
    
    struct sockaddr_in localaddr;
    socklen_t addrlen = sizeof(localaddr);
    if(getsockname(sockfd, (struct sockaddr*)&localaddr, &addrlen) < 0)
    {
        perror("getsockname error");
        exit(0);
    }
    
    printf("ip=%s  port=%d
", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));
    
    echo_cli(sockfd);
    
    return 0;
}

核心函数为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 (0)

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 = 0;
    if (wait_seconds > 0)
    {
        fd_set read_fdset;
        struct timeval timeout;

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

        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        
        //select返回值三态
        //1 若timeout时间到（超时），没有检测到读事件 ret返回=0
        //2 若ret返回<0 &&  errno == EINTR 说明select的过程中被别的信号中断（可中断睡眠原理）
        //2-1 若返回-1，select出错
        //3 若ret返回值>0 表示有read事件发生，返回事件发生的个数
        
        do
        {
            ret = select(fd + 1, &read_fdset, NULL, NULL, &timeout);
        } while (ret < 0 && errno == EINTR);

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

    return ret;
}

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

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

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

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

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

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

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

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

    flags &= ~O_NONBLOCK;
    ret = fcntl(fd, F_SETFL, flags);
    if (ret == -1)
        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 > 0)
        activate_nonblock(fd);

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

        nread = ret;
        int i;
        for (i=0; i<nread; i++)
        {
            if (bufp[i] == '
')
            {
                ret = readn(sockfd, bufp, i+1);
                if (ret != i+1)
                    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 -1;
}

上述带超时的函数，具有一定的健壮性，将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是否发生了变化。