同步IO、异步IO以及五种网络IO模式

一、同步IO和异步IO

二、五种网络IO模式

1、阻塞IO

2、非阻塞IO

3、IO多路复用

3.1、SELECT

3.2、POLL

3.3、EPOLL

一、同步IO和异步IO

场景1：小明去打开水，而开水塔此时没有水，小明在现场一直等待开水到来，或者不断的轮询查看是否有开水，直到有开水取到水为止，这是同步IO的一种案例！

同步IO的特点：

同步IO指的是用户进程触发I/O操作并等待或者轮询的去查看I/O操作是否就绪。
同步IO的执行者是IO操作的发起者。
同步IO需要发起者进行内核态到用户态的数据拷贝过程，所以这里必须阻塞

场景2：小明去打开水，而开水塔此时没有水，开水塔的阿姨叫小明把水壶放到现场，来水后会帮他打好水，并打电话叫他来取，这是异步IO的一种案例！

异步IO的特点：

异步IO是指用户进程触发I/O操作以后就立即返回，继续开始做自己的事情，而当I/O操作已经完成的时候会得到I/O完成的通知。
异步IO的执行者是内核线程，内核线程将数据从内核态拷贝到用户态，所以这里没有阻塞

二、五种网络IO模式

对于一次IO访问（以read为例），数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间。所以说，当一个read操作发生时，会经历两个阶段：
　　1、等待数据准备 
    2、将数据从内核拷贝到进程中

linux系统产生了下面五种网络模式的方案：
　　1、阻塞IO（blocking IO）
　　2、非阻塞IO（nonblocking IO）
　　3、IO多路复用（IO multiplexing）
　　4、信号驱动IO（signal driven IO）不常用
5、异步IO （asynchronous IO）

1、阻塞IO

小明同学急用开水，打开水时发现开水龙头没水，他一直等待直到装满水然后离开。这一过程就可以看成是使用了阻塞IO模型，因为如果水龙头没有水，他也要等到有水并装满杯子才能离开去做别的事情。很显然，这种IO模型是同步的。

在linux 中，默认情况下所有的socket都是blocking IO, 一个典型的读操作流程：

2、非阻塞IO

小明同学又一次急用开水，打开水龙头后发现没有水，因为还有其它急事他马上离开了，过一会他又拿着杯子来看看……在中间离开的这些时间里，小明同学离开了装水现场(回到用户进程空间)，可以做他自己的事情。这就是非阻塞IO模型。但是它只有是检查无数据的时候是非阻塞的，在数据到达的时候依然要等待复制数据到用户空间(等着水将水杯装满)，因此它还是同步IO。

当用户线程发起一个read操作后，并不需要等待，而是马上就得到了一个结果。如果结果是一个error时，它就知道数据还没有准备好，于是它可以再次发送read操作。一旦内核中的数据准备好了，并且又再次收到了用户线程的请求，那么它马上就将数据拷贝到了用户线程，然后返回。

所以事实上，在非阻塞IO模型中，用户线程需要不断地询问内核数据是否就绪，也就说非阻塞IO不会交出CPU，而会一直占用CPU。

典型的非阻塞IO模型一般如下：

设置非阻塞常用方式：
方式一: 创建socket 时指定
int s = socket(AF_INET, SOCK_STREAM | SOCK_NONBLOCK, IPPROTO_TCP);

方式二: 在使用前通过如下方式设定
fcntl(sockfd, F_SETFL, fcntl(sockfd, F_GETFL, 0) | O_NONBLOCK);

3、IO多路复用

有一天，学校里面优化了热水的供应，增加了很多水龙头，这个时候小明同学再去装水，舍管阿姨告诉他这些水龙头都还没有水，你可以去忙别的了，等有水了告诉他。于是等啊等(select调用中)，过了一会阿姨告诉他有水了。

这里有两种情况：

情况1: 阿姨只告诉来水了，但没有告诉小明是哪个水龙头来水了，要自己一个一个去尝试。(select/poll 场景)
情况2: 舍管阿姨会告诉小明同学哪几个水龙头有水了，小明同学不需要一个个打开看(epoll 场景)

当用户进程调用了select，那么整个进程就会被block，而同时，kernel会 “监视”所有select负责的socket，当任何一个socket中的数据准备好了，select就会返回。这个时候用户进程再调用read操作，将数据从kernel拷贝到用户进程。

所以，IO多路复用的特点是通过一种机制，一个进程能同时等待多个文件描述符，而这些文件描述符（套接字描述符）其中的任意一个进入就绪状态，select()函数就可以返回。

这里需要使用两个system call（select 和 recvfrom），而blocking IO只调用了一个system call（recvfrom）。但是，用select的优势在于它可以同时处理多个connection。

如果处理的连接数不是很高的话，使用select/epoll的web server不一定比使用mutil-threading + blocking IO的web server性能更好，可能延迟还更大。select/epoll 的优势并不是对于单个连接能处理得更好，而是在于能同时处理更多的连接。

3.1、SELECT

在一段指定的时间内，监听用户感兴趣的文件描述符上可读、可写和异常等事件。

#include <sys/select.h>
int select(int nfds, fd_set *readfds, fd_set *writefds,
                  fd_set *exceptfds, struct timeval *timeout);
nfds ：   最大的文件描述符加1。
readfds： 用于检查可读的。
writefds：用于检查可写性。
exceptfds：用于检查异常的数据。
timeout：一个指向timeval结构的指针，用于决定select等待I/o的最长时间。如果为空将一直等待。
timeval结构的定义：
struct timeval{
long tv_sec; // seconds
long tv_usec; // microseconds
}
返回值：  >0  是已就绪的文件句柄的总数， =0 超时, <0 表示出错，错误: errno 

#include <sys/select.h> 
int FD_ZERO(fd_set *fdset); //一个 fd_set类型变量的所有位都设为 0 
int FD_CLR(int fd, fd_set *fdset); //清除某个位时可以使用 
int FD_SET(int fd, fd_set *fd_set); //设置变量的某个位置位 
int FD_ISSET(int fd, fd_set *fdset); //测试某个位是否被置位

经典案例:

服务器端 server.c

#include <sys/types.h> 
#include <sys/socket.h> 
#include <stdio.h> 
#include <netinet/in.h> 
#include <sys/time.h> 
#include <sys/ioctl.h> 
#include <unistd.h> 
#include <stdlib.h>

int main()
{
    int server_sockfd, client_sockfd;
    int server_len, client_len;
    struct sockaddr_in server_address;
    struct sockaddr_in client_address;
    int result;
    fd_set readfds, testfds;
    server_sockfd = socket(AF_INET, SOCK_STREAM, 0);//建立服务器端socket 
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = htonl(INADDR_ANY);
    server_address.sin_port = htons(9000);
    server_len = sizeof(server_address);
    bind(server_sockfd, (struct sockaddr*)&server_address, server_len);
    listen(server_sockfd, 5); //监听队列最多容纳5个 
    FD_ZERO(&readfds);
    FD_SET(server_sockfd, &readfds);//将服务器端socket加入到集合中
    while (1)
    {
        char ch;
        int fd;
        int nread;
        testfds = readfds;//将需要监视的描述符集copy到select查询队列中，select会对其修改，所以一定要分开使用变量 
        printf("server waiting\n");

        /*无限期阻塞，并测试文件描述符变动 */
        result = select(FD_SETSIZE, &testfds, (fd_set*)0, (fd_set*)0, (struct timeval*)0); //FD_SETSIZE：系统默认的最大文件描述符
        if (result < 1)
        {
            perror("server5");
            exit(1);
        }

        /*扫描所有的文件描述符*/
        for (fd = 0; fd < FD_SETSIZE; fd++)
        {
            /*找到相关文件描述符*/
            if (FD_ISSET(fd, &testfds))
            {
                /*判断是否为服务器套接字，是则表示为客户请求连接。*/
                if (fd == server_sockfd)
                {
                    client_len = sizeof(client_address);
                    client_sockfd = accept(server_sockfd,
                        (struct sockaddr*)&client_address, &client_len);
                    FD_SET(client_sockfd, &readfds);//将客户端socket加入到集合中
                    printf("adding client on fd %d\n", client_sockfd);
                }
                /*客户端socket中有数据请求时*/
                else
                {
                    ioctl(fd, FIONREAD, &nread);//取得数据量交给nread

                    /*客户数据请求完毕，关闭套接字，从集合中清除相应描述符 */
                    if (nread == 0)
                    {
                        close(fd);
                        FD_CLR(fd, &readfds); //去掉关闭的fd
                        printf("removing client on fd %d\n", fd);
                    }
                    /*处理客户数据请求*/
                    else
                    {
                        read(fd, &ch, 1);
                        sleep(5);
                        printf("serving client on fd %d\n", fd);
                        ch++;
                        write(fd, &ch, 1);
                    }
                }
            }
        }
    }

    return 0;
}

服务器端 client.c

#include <sys/types.h> 
#include <sys/socket.h> 
#include <stdio.h> 
#include <netinet/in.h> 
#include <arpa/inet.h> 
#include <unistd.h> 
#include <stdlib.h>
#include <sys/time.h>

int main()
{
    int client_sockfd;
    int len;
    struct sockaddr_in address;//服务器端网络地址结构体 
    int result;
    char ch = 'A';
    client_sockfd = socket(AF_INET, SOCK_STREAM, 0);//建立客户端socket 
    address.sin_family = AF_INET;
    address.sin_addr.s_addr = inet_addr("127.0.0.1");
    address.sin_port = htons(9000);
    len = sizeof(address);
    result = connect(client_sockfd, (struct sockaddr*)&address, len);
    if (result == -1)
    {
        perror("oops: client2");
        exit(1);
    }
    //第一次读写
    write(client_sockfd, &ch, 1);
    read(client_sockfd, &ch, 1);
    printf("the first time: char from server = %c\n", ch);
    sleep(5);

    //第二次读写
    write(client_sockfd, &ch, 1);
    read(client_sockfd, &ch, 1);
    printf("the second time: char from server = %c\n", ch);

    close(client_sockfd);

    return 0;
}

3.2、POLL

和select 一样，如果没有事件发生，则进入休眠状态，如果在规定时间内有事件发生，则返回成功，规定时间过后仍然没有事件发生则返回失败。可见，等待期间将进程休眠，利用事件驱动来唤醒进程，将更能提高CPU的效率。

poll 和select 区别：  select 有文件句柄上线设置，值为FD_SETSIZE，
而poll 理论上没有限制!
 #include <poll.h>
       int poll(struct pollfd *fds, nfds_t nfds, int timeout);

      输入参数：
            fds：//可以传递多个结构体，也就是说可以监测多个驱动设备所产生的事件，只要有一个产生了请求事件，就能立即返回
            struct pollfd {
                  int fd;                /*文件描述符   open打开的那个*/
                  short events;     /*请求的事件类型，监视驱动文件的事件掩码*/  POLLIN | POLLOUT
                  short revents;    /*驱动文件实际返回的事件*/
            }
            nfds:  //监测驱动文件的个数
            timeout://超时时间，单位是ms
事件类型events 可以为下列值：
        POLLIN           有数据可读
        POLLRDNORM 有普通数据可读，等效与POLLIN
        POLLPRI         有紧迫数据可读
        POLLOUT        写数据不会导致阻塞
        POLLER          指定的文件描述符发生错误
        POLLHUP        指定的文件描述符挂起事件
        POLLNVAL      无效的请求，打不开指定的文件描述符
返回值：
        有事件发生  返回revents域不为0的文件描述符个数
        超时：return 0
        失败：return  -1   错误：errno

服务器端 server_poll.c

#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdio.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <sys/ioctl.h>
#include <unistd.h>
#include <stdlib.h>
#include <poll.h>

#define MAX_FD  8192
struct pollfd  fds[MAX_FD];
int cur_max_fd = 0;


int main()
{
    int server_sockfd, client_sockfd;
    int server_len, client_len;
    struct sockaddr_in server_address;
    struct sockaddr_in client_address;
    int result;
    //fd_set readfds, testfds;
    server_sockfd = socket(AF_INET, SOCK_STREAM, 0);//建立服务器端socket
    server_address.sin_family = AF_INET;
    server_address.sin_addr.s_addr = htonl(INADDR_ANY);
    server_address.sin_port = htons(9000);
    server_len = sizeof(server_address);
    bind(server_sockfd, (struct sockaddr*)&server_address, server_len);
    listen(server_sockfd, 5); //监听队列最多容纳5个
    //FD_ZERO(&readfds);
    //FD_SET(server_sockfd, &readfds);//将服务器端socket加入到集合中
    fds[server_sockfd].fd = server_sockfd;
    fds[server_sockfd].events = POLLIN;
    fds[server_sockfd].revents = 0;
    if(cur_max_fd <= server_sockfd)
    {
        cur_max_fd = server_sockfd + 1;
    }


    while (1)
    {
        char ch;
        int i, fd;
        int nread;
        //testfds = readfds;//将需要监视的描述符集copy到select查询队列中，select会对其修改，所以一定要分开使用变量
        printf("server waiting\n");

        /*无限期阻塞，并测试文件描述符变动 */
        result = poll(fds, cur_max_fd, 1000);
        //result = select(FD_SETSIZE, &testfds, (fd_set*)0, (fd_set*)0, (struct timeval*)0); //FD_SETSIZE：系统默认的最大文件描述符
        if (result < 0)
        {
            perror("server5");
            exit(1);

        }
        /*扫描所有的文件描述符*/
        for (i = 0; i < cur_max_fd; i++)
        {

            /*找到相关文件描述符*/
            if (fds[i].revents)
            {
                fd = fds[i].fd;
                /*判断是否为服务器套接字，是则表示为客户请求连接。*/
                if (fd == server_sockfd)
                {
                    client_len = sizeof(client_address);
                    client_sockfd = accept(server_sockfd,
                        (struct sockaddr*)&client_address, &client_len);
                    fds[client_sockfd].fd = client_sockfd;//将客户端socket加入到集合中
                    fds[client_sockfd].events = POLLIN;
                    fds[client_sockfd].revents = 0;


                    if(cur_max_fd <= client_sockfd)
                    {
                        cur_max_fd = client_sockfd + 1;
                    }

                    printf("adding client on fd %d\n", client_sockfd);
                    //fds[server_sockfd].events = POLLIN;
                }
                /*客户端socket中有数据请求时*/
                else
                {
                    //ioctl(fd, FIONREAD, &nread);//取得数据量交给nread
                    nread = read(fd, &ch, 1);
                    /*客户数据请求完毕，关闭套接字，从集合中清除相应描述符 */
                    if (nread == 0)
                    {
                        close(fd);
                        memset(&fds[i], 0, sizeof(struct pollfd)); //去掉关闭的fd
                        printf("removing client on fd %d\n", fd);
                    }
                    /*处理客户数据请求*/
                    else
                    {
                        //read(fds[fd].fd, &ch, 1);
                        sleep(5);
                        printf("serving client on fd %d, read: %c\n", fd, ch);
                        ch++;
                        write(fd, &ch, 1);
                        //fds[fd].events = POLLIN;
                    }
                }
            }
        }
    }

    return 0;
}