作为程序员，在日常工作中，都或多或少的接触过网络I/O这个概念，接触过网络编程，听说过socket等等，但是对于更深层次的理解，多少还是有点欠缺，通过本文，可以了解网络中最重要的模块I/O，以及对几种网络模型的介绍，在我们日常工作开发过程中，可以针对特定需求，选择特定的网络模型，达到事半功倍的效果。

0 什么是I/O

通常指数据,在内部存储器和外部存储器或其他周边设备之间的输入和输出。

是信息处理系统（例如计算器）与外部世界（可能是人类或另一信息处理系统）之间的通信。输入是系统接收的信号或数据，输出则是从其发送的信号或数据。该术语也可以用作行动的一部分；到“运行I/O”是运行输入或输出的操作。

Unix 系统下，不论是标准输入还是借助套接字接受网络输入，都有两个步骤：

• 等待数据准备好（Waiting for the data to be ready）
• 从内核向进程复制数据（Copying the data from the kernel to the process）

?

输入/出设备是硬件中由人（或其他系统）使用与计算器进行通信的部件。例如，键盘或鼠标是计算器的输入设备，而监视器和打印机是输出设备。计算器之间的通信设备（如电信调制解调器和网卡）通常运行输入和输出操作。 简单来说，就是用户进程与内核交互，而内核与硬件进行交互。

?

1 阻塞式I/O模型

应用程序发起I/O系统调用，在获得结果之前，应用程序进程会一直阻塞，直到获得结果(有数据返回或者操作超时)。

默认情况下，Unix系统上的所有文件描述符都以“阻塞模式”开始。这意味着read、write或connect之类的I/O系统调用在默认情况下，都是阻塞的。

为了理解这一点，我们假如有个程序，在终端上等待标准输入(stdin)，此时，假如通过调用read函数来实现该功能，那么该程序将被阻塞，直到有实际的数据可用(例如当用户在键盘上敲入字符时)。具体来说，内核将把进程置于“休眠”状态，直到数据在stdin上可用。其他类型的文件描述符也是如此。例如，如果您尝试从TCP套接字读取数据，那么read调用将阻塞，直到连接的另一端实际发送数据为止。

int main(int argc, char *argv[]) {
    char buf[ MAX_BUFFER_LENGTH ];
    int length = 0;
    if( (length = read( 0, buf,  MAX_BUFFER_LENGTH )) < 0 ) {
        return -1;
    }
    buf[length] = '\0';
    printf("input: \n%s\n", buf);
    return 0;
}

?

当在我们执行了上述代码，那么，在该执行代码的进程内，会调用read函数，最终会进入kernel态，此时，会进入kernel态的第一个步骤即I/O等待数据状态。

从用户进程的角度来说，会被阻塞。直到超时或者键盘输入了数据，从kernel态将数据拷贝到了用户态的内存，此时用户进程才接触阻塞，程序开始执行下面其他步骤。

特点：
用户进程会一直阻塞等待kernel，直到kernel将数据返回

2 非阻塞式I/O模型

通常通过将socket描述符设置为O_NONBLOCK模式。

int flags = fcntl(fd, F_GETFL, 0);
fcntl(fd, F_SETFL, flags | O_NONBLOCK);

如果一个socket描述符被设置为非阻塞的，那么在数据准备好之前，调用read函数，会返回-1，而errno会被设置为EWOULDBLOCK。

?

从上图可以看出，当在用户进程调用read系统调用之后，如果kernel态没有数据，那么read调用会马上返回，而不会阻塞用户进程。用户进程判断结果是一个error时，它就知道数据还没有准备好，于是用户就可以在本次到下次再发起read询问的时间间隔内做其他事情，或者直接再次发送read操作。一旦kernel中的数据准备好了，并且又再次收到了用户进程的system call，那么它马上就将数据拷贝到了用户内存（这一阶段仍然是阻塞的），然后返回。

整个过程，可以概括为，用户进程不断的调用read系统调用，询问kernel数据是否准备好，所以，非阻塞式I/O模式可以理解为是一个不断循环询问kernel的模式。

struct timespec sleep_interval{.tv_sec = 0, .tv_nsec = 1000};
ssize_t nbytes;
for (;;) {
    /* try fd1 */
    if ((nbytes = read(fd1, buf, sizeof(buf))) < 0) {
        if (errno != EWOULDBLOCK) {
            perror("read/fd1");
        }
    } else {
        handle_data(buf, nbytes);
    }
    /* try fd2 */
    if ((nbytes = read(fd2, buf, sizeof(buf))) < 0) {
        if (errno != EWOULDBLOCK) {
            perror("read/fd2");
        }
    } else {
        handle_data(buf, nbytes);
    }
    /* 处理其他事情 */
    // do other
}

非阻塞式I/O较阻塞式I/O来说，性能提升了很多，但仍然存在很多问题，比如:

1、当数据输入非常慢时，程序会频繁而不必要地唤醒，从而浪费CPU资源。

2、当数据进入时，如果程序处于睡眠状态或者正在处理其他逻辑，它可能不会立即读取数据，因此程序的延迟将很差。

3、用这种模式处理大量的文件描述符将变得很麻烦。

特点：
1、用户进程会不断的询问kernel数据是否已经准备好
2、抽象的讲，非阻塞I/O与异步I/O类似，区别是一个不断的去轮询kernel，一个是通过被动通知的方式。2、抽象的讲，非阻塞I/O与异步I/O类似，区别是一个不断的去轮询kernel，一个是通过被动通知的方式。

3 信号驱动式I/O模型

当进程发起一个IO操作，会向内核注册一个信号处理函数，然后进程返回不阻塞；当内核数据就绪时会发送一个信号给进程，进程便在信号处理函数中调用IO读取数据。

?

信号驱动式I/O在TCP中用处不大，这是因为该信号在TCP套接字中产生的过于频繁。
以下条件均会导致对一个TCP套接字产生SIGIO信号：

• 监听套接字上某个连接请求已经完成；
• 某个断连请求已经发起；
• 某个断连请求已经完成；
• 某个连接对端已经关闭；
• 数据到达套接字；
• 数据已经从套接字发送走；
• 发生某个异步错误。

当然，我们可以对TCP监听套接字可以使用SIGIO，这样我们就可以在信号处理函数中处理新连接了。

对于UDP，只有以下两个条件才会产生SIGIO信号：

• 数据报到达套接字；
• 套接字上发生异步错误。

所以，针对UDP套接字产生的SIGIO信号，我们只要调用recvfrom读入到达的数据，或者获取发生的异步错误就可以了。

void io_handler(int signal) {
  int       numbytes;  /* Number of bytes recieved from client */
  int       addr_len;  /* Address size of the sender    */
  struct sockaddr_in   their_addr;  /* connector's address information  */
 
  if ((numbytes=recvfrom(sock, buf, MAXBUFLEN, 0, \
                    (struct sockaddr *)&their_addr, &addr_len)) == -1) {
                perror("recvfrom");
                exit(1);
   }
 
  buf[numbytes]='\0';
  printf("got from %s --->%s \n  ",inet_ntoa(their_addr.sin_addr),buf);
  return;
}
int main() {
  int length;
  struct sockaddr_in server;
  
  sock = socket(AF_INET, SOCK_DGRAM, 0);
  if (sock < 0) {
    perror("opening datagram socket");
    exit(1);
  }
  server.sin_family = AF_INET;
  server.sin_addr.s_addr = INADDR_ANY;
  server.sin_port = htons(MYPORT);
  if (bind(sock, (struct sockaddr *)&server, sizeof server) <0 ){
    perror("binding datagram socket");
    exit(1);
  }
  length = sizeof(server);
  if (getsockname(sock, (struct sockaddr *)&server, &length) < 0){
    perror("getting socket name");
    exit(1);
  }
  printf("Socket port #%d\n", ntohs(server.sin_port));
  // 第一步，注册事件函数
  signal(SIGIO,io_handler);
  // 第二步 设置要接收的进程id或进程组id，通知其自己的进程id或进程的挂起输入组id
  if (fcntl(sock,F_SETOWN, getpid()) < 0){
    perror("fcntl F_SETOWN");
    exit(1);
  }
  // 第三步，允许接收异步I/O信号
  if (fcntl(sock,F_SETFL,FASYNC) <0 ){
    perror("fcntl F_SETFL, FASYNC");
    exit(1);
  }
  for(;;)
  ;
  // .......
  }

> 该模式比较复杂，在实际使用中不是很多，在内核2.6中才开始引入。

## 4 异步I/O模型

同步I/O意味着当您想读或写某个东西时，可能需要调用一个名为read（）或write（）的函数，函数会阻塞，阻止执行进一步移动，直到读或写完成。这就是普通文件读写的典型工作方式。打开一个文件，然后调用read（），它用所需的数据填充一个缓冲区，并在完成所有操作后返回，这样就可以用所需的数据填充一个缓冲区。

异步I/O恰恰相反。与读写函数等待请求的操作完成后再返回不同，异步I/O操作将立即返回到程序，而读写操作将在后台继续。

这有什么好处？这意味着你的程序或游戏可以继续扔东西在屏幕上，更新输入，滚动进度条，无论什么，而所有的硬盘驱动器的数据处理你想要的。您还可以向系统发送多个IO请求，这样操作系统就可以找到访问所有所需数据的最有效方法。

?

用户进程发起read操作之后，立刻就可以开始去做其它的事。而另一方面，从kernel的角度，当它受到一个asynchronous read之后，首先它会立刻返回，所以不会对用户进程产生任何block。然后，kernel会等待数据准备完成，然后将数据拷贝到用户内存，当这一切都完成之后，kernel会给用户进程发送一个signal，告诉它read操作完成了。

在异步IO中，以下几个概念非常重要:

struct aiocb {
  int             aio_fildes;     /* 文件描述符 */
  off_t           aio_offset;     /* 文件便宜 */
  volatile void  *aio_buf;        /* buffer位置 */
  size_t          aio_nbytes;     /* 传输数据大小 */
  int             aio_reqprio;    /* 请求优先级 */
  struct sigevent aio_sigevent;   /* 通知的方式 */
  int             aio_lio_opcode; 
};

aio_read()
函数告诉系统要读取的文件、开始读取的偏移量、要读取的字节数以及要将要读取的字节放在何处。
aio_error()
检查IO请求的当前状态。使用这个函数你可以查出请求是否成功。你所要做的就是给它一个地址，地址和你给aio\u read（）的地址相同。如果请求成功完成，则函数返回0；如果请求仍在工作，则返回EINPROGRESS；如果发生错误，则返回其他错误代码。
aio_return()
检查IO请求的结果，一旦您发现请求已经完成。如果请求成功，此函数返回读取的字节数。如果失败，那么函数返回-1。

下面是异步I/O模型的一个简单例子，通过本例，可以简单的了解该模型的大致流程。

int main(){
  int file = open("blah.txt", O_RDONLY, 0);
 
  if (file == -1)
  {
    cout << "Unable to open file!" << endl;
    return 1;
  }
  
  char* buffer = new char[SIZE_TO_READ];
 
  // 定义控制块变量
  aiocb cb;
 
  memset(&cb, 0, sizeof(aiocb));
  cb.aio_nbytes = SIZE_TO_READ;
  cb.aio_fildes = file;
  cb.aio_offset = 0;
  cb.aio_buf = buffer;
 
  // 读取数据
  if (aio_read(&cb) == -1)
  {
    cout << "Unable to create request!" << endl;
    close(file);
  }
 
  cout << "Request enqueued!" << endl;
 
  // 等待，知道请求处理完成
  while(aio_error(&cb) == EINPROGRESS)
  {
    cout << "Working..." << endl;
  }
 
  // 判断读取的字节数
  int numBytes = aio_return(&cb);
 
  if (numBytes != -1)
    cout << "Success!" << endl;
  else
    cout << "Error!" << endl;
 
  // 释放资源
  delete[] buffer;
  close(file);
 
  return 0;
}

特点：
1、用户程序告诉kernel其要执行某个操作，不等kernel回复就立即返回
2、kernel完成整个操作，包括将获取的数据拷贝到用户的buffer之后，再通知用户。

5 I/O多路复用

I/O多路复用是这样一种能力，它告诉内核，如果一个或多个I/O条件已经就绪，比如输入已经准备好被读取，或者描述符能够获取更多的输出，我们就需要得到通知。

I/O复用模型使用select、poll、epoll函数，这些函数也会阻塞进程，但与阻塞I/O不同的是，这两个函数可以同时阻塞多个I/O操作。对于多个读操作、多个写操作，可以同时检测I/O函数，直到有数据可读或可写时，才实际调用I/O操作函数。

?

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

int         maxfdp1, stdineof;
fd_set      rset;
char        buf[MAXLINE];
int     n;
stdineof = 0;
FD_ZERO(&rset);
for ( ; ; ) {
    if (stdineof == 0)
        FD_SET(fileno(fp), &rset);
    FD_SET(sockfd, &rset);
    maxfdp1 = max(fileno(fp), sockfd) + 1;
    select(maxfdp1, &rset, NULL, NULL, NULL);
    if (FD_ISSET(sockfd, &rset)) {  /* socket is readable */
        if ( (n = read(sockfd, buf, MAXLINE)) == 0) {
            if (stdineof == 1)
                return;     /* normal termination */
            else
                err_quit("str_cli: server terminated prematurely");
        }
        write(fileno(stdout), buf, n);
    }
    if (FD_ISSET(fileno(fp), &rset)) {  /* input is readable */
        if ( (n = read(fileno(fp), buf, MAXLINE)) == 0) {
            stdineof = 1;
            shutdown(sockfd, SHUT_WR);  /* send FIN */
            FD_CLR(fileno(fp), &rset);
            continue;
            }
        writen(sockfd, buf, n);
    }
}

IO多路复用适用如下场合：

（1）当客户处理多个描述字时（一般是交互式输入和网络套接口）

（2）当一个客户同时处理多个套接口时，而这种情况是可能的，但很少出现。

（3）如果一个TCP服务器既要处理监听套接口，又要处理已连接套接口，一般也要用到I/O复用。

（4）如果一个服务器即要处理TCP，又要处理UDP

（5）如果一个服务器要处理多个服务或多个协议

1、多路复用模式有select、poll以及epoll函数，每个函数的性能特点以及开发难以程度各不同，需要根据实际需求，择优选择。

2、现在基本上所有的商用或者大型程序，都是用的多路复用与非阻塞两个模式相结合的方式

参考资料

https://fwheel.net/aio.html

https://www.itzhai.com/articles/it-seems-not-so-perfect-signal-driven-io.html

https://eklitzke.org/blocking-io-nonblocking-io-and-epoll

https://notes.shichao.io/unp/ch6/