聊聊Linux 五种IO模型

0 系列目录

• 聊聊远程通信

  • Java远程通讯技术及原理分析
  • 聊聊Socket、TCP/IP、HTTP、FTP及网络编程
  • RMI原理及实现
  • RPC原理及实现
  • 轻量级分布式 RPC 框架
  • 使用 RMI + ZooKeeper 实现远程调用框架
  • 深入浅出SOA思想
  • 微服务、SOA 和 API对比与分析
  • 聊聊同步、异步、阻塞与非阻塞
  • 聊聊Linux 五种IO模型
  • 聊聊IO多路复用之select、poll、epoll详解
  • 聊聊C10K问题及解决方案

上一篇 《聊聊同步、异步、阻塞与非阻塞》 已经通俗的讲解了，要理解同步、异步、阻塞与非阻塞重要的两个概念点了，没有看过的，建议先看这篇博文理解这两个概念点。在认知上，建立统一的模型。这样，大家在继续看本篇时，才不会理解有偏差。

那么，在正式开始讲Linux IO模型前，比如：同步IO和异步IO，阻塞IO和非阻塞IO分别是什么，到底有什么区别？不同的人在不同的上下文下给出的答案是不同的。所以先限定一下本文的上下文。

1 概念说明

在进行解释之前，首先要说明几个概念：

1.1 用户空间与内核空间

现在操作系统都是采用虚拟存储器，那么对32位操作系统而言，它的寻址空间（虚拟存储空间）为4G（2的32次方）。 操作系统的核心是内核，独立于普通的应用程序，可以访问受保护的内存空间，也有访问底层硬件设备的所有权限 。为了保证用户进程不能直接操作内核（kernel），保证内核的安全， 操作系统将虚拟空间划分为两部分，一部分为内核空间，一部分为用户空间 。针对linux操作系统而言，将最高的1G字节（从虚拟地址0xC0000000到0xFFFFFFFF），供内核使用，称为内核空间，而将较低的3G字节（从虚拟地址0×00000000到0xBFFFFFFF），供各个进程使用，称为用户空间。

1.2 进程切换

为了控制进程的执行，内核必须有能力挂起正在CPU上运行的进程，并恢复以前挂起的某个进程的执行。这种行为被称为进程切换。因此可以说，任何进程都是在操作系统内核的支持下运行的，是与内核紧密相关的。

从一个进程的运行转到另一个进程上运行，这个过程中经过下面这些变化：

注：总而言之就是很耗资源，具体的可以参考这篇文章： 进程切换 。

1.3 进程的阻塞

正在执行的进程，由于期待的某些事件未发生，如请求系统资源失败、等待某种操作的完成、新数据尚未到达或无新工作做等，则由系统自动执行阻塞原语(Block)，使自己由运行状态变为阻塞状态。可见，进程的阻塞是进程自身的一种主动行为，也因此只有处于运行态的进程（获得CPU），才可能将其转为阻塞状态。 当进程进入阻塞状态，是不占用CPU资源的 。

1.4 文件描述符fd

文件描述符（File descriptor）是计算机科学中的一个术语， 是一个用于表述指向文件的引用的抽象化概念 。

文件描述符在形式上是一个非负整数。实际上， 它是一个索引值，指向内核为每一个进程所维护的该进程打开文件的记录表 。当程序打开一个现有文件或者创建一个新文件时，内核向进程返回一个文件描述符。在程序设计中，一些涉及底层的程序编写往往会围绕着文件描述符展开。但是文件描述符这一概念往往只适用于UNIX、Linux这样的操作系统。

1.5 缓存 IO

缓存 IO 又被称作标准 IO，大多数文件系统的默认 IO 操作都是缓存 IO 。在 Linux 的缓存 IO 机制中，操作系统会将 IO 的数据缓存在文件系统的页缓存（ page cache ）中，也就是说， 数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间 。

缓存 IO 的缺点：

数据在传输过程中需要在应用程序地址空间和内核进行多次数据拷贝操作 ，这些数据拷贝操作所带来的 CPU 以及内存开销是非常大的。

2 Linux IO模型

网络IO的本质是socket的读取，socket在linux系统被抽象为流，IO可以理解为对流的操作 。刚才说了，对于一次IO访问（以read举例）， 数据会先被拷贝到操作系统内核的缓冲区中，然后才会从操作系统内核的缓冲区拷贝到应用程序的地址空间 。所以说，当一个read操作发生时，它会经历两个阶段：

对于socket流而言，

网络应用需要处理的无非就是两大类问题， 网络IO，数据计算 。相对于后者，网络IO的延迟，给应用带来的性能瓶颈大于后者。网络IO的模型大致有如下几种：

注：由于signal driven IO在实际中并不常用，所以我这只提及剩下的四种IO Model。

在深入介绍Linux IO各种模型之前，让我们先来探索一下基本 Linux IO 模型的简单矩阵。如下图所示：

每个 IO 模型都有自己的使用模式，它们对于特定的应用程序都有自己的优点。本节将简要对其一一进行介绍。 常见的IO模型有阻塞、非阻塞、IO多路复用，异步 。以一个生动形象的例子来说明这四个概念。周末我和女友去逛街，中午饿了，我们准备去吃饭。周末人多，吃饭需要排队，我和女友有以下几种方案。

2.1 同步阻塞 IO（blocking IO）

2.1.1 场景描述

2.1.2 网络模型

同步阻塞 IO 模型是最常用的一个模型，也是最简单的模型 。在linux中， 默认情况下所有的socket都是blocking 。它符合人们最常见的思考逻辑。 阻塞就是进程 "被" 休息, CPU处理其它进程去了 。

在这个IO模型中，用户空间的应用程序执行一个系统调用（recvform），这会导致应用程序阻塞，什么也不干，直到数据准备好，并且将数据从内核复制到用户进程，最后进程再处理数据， 在等待数据到处理数据的两个阶段 ，整个进程都被阻塞。不能处理别的网络IO。 调用应用程序处于一种不再消费 CPU 而只是简单等待响应的状态 ，因此从处理的角度来看，这是非常有效的。在调用recv()/recvfrom()函数时，发生在内核中等待数据和复制数据的过程，大致如下图：

2.1.3 流程描述

当用户进程调用了recv()/recvfrom()这个系统调用， kernel就开始了IO的第一个阶段：准备数据 （对于网络IO来说，很多时候数据在一开始还没有到达。比如，还没有收到一个完整的UDP包。这个时候kernel就要等待足够的数据到来）。这个过程需要等待，也就是说数据被拷贝到操作系统内核的缓冲区中是需要一个过程的。而在用户进程这边，整个进程会被阻塞（当然，是进程自己选择的阻塞）。 第二个阶段：当kernel一直等到数据准备好了，它就会将数据从kernel中拷贝到用户内存 ，然后kernel返回结果，用户进程才解除block的状态，重新运行起来。

优点：

缺点：

2.2 同步非阻塞 IO（nonblocking IO）

2.2.1 场景描述

2.2.2 网络模型

同步非阻塞就是 “每隔一会儿瞄一眼进度条” 的轮询（polling）方式 。在这种模型中， 设备是以非阻塞的形式打开的 。这意味着 IO 操作不会立即完成，read 操作可能会返回一个错误代码，说明这个命令不能立即满足（EAGAIN 或 EWOULDBLOCK）。

在网络IO时候，非阻塞IO也会进行recvform系统调用，检查数据是否准备好，与阻塞IO不一样，”非阻塞将大的整片时间的阻塞分成N多的小的阻塞, 所以进程不断地有机会 ‘被’ CPU光顾”。

也就是说非阻塞的recvform系统调用调用之后，进程并没有被阻塞，内核马上返回给进程，如果数据还没准备好，此时会返回一个error 。进程在返回之后，可以干点别的事情，然后再发起recvform系统调用。重复上面的过程，循环往复的进行recvform系统调用。 这个过程通常被称之为轮询 。轮询检查内核数据，直到数据准备好，再拷贝数据到进程，进行数据处理。 需要注意，拷贝数据整个过程，进程仍然是属于阻塞的状态 。

在linux下，可以通过设置socket使其变为non-blocking。 当对一个non-blocking socket执行读操作时 ，流程如图所示：

2.2.3 流程描述

当用户进程发出read操作时，如果kernel中的数据还没有准备好，那么它并不会block用户进程，而是立刻返回一个error。从用户进程角度讲，它发起一个read操作后，并不需要等待，而是马上就得到了一个结果。用户进程判断结果是一个error时，它就知道数据还没有准备好，于是它可以再次发送read操作。一旦kernel中的数据准备好了，并且又再次收到了用户进程的system call，那么它马上就将数据拷贝到了用户内存，然后返回。

同步非阻塞方式相比同步阻塞方式：

2.3 IO 多路复用（ IO multiplexing）

2.3.1 场景描述

2.3.2 网络模型

由于同步非阻塞方式需要不断主动轮询，轮询占据了很大一部分过程，轮询会消耗大量的CPU时间，而 “后台” 可能有多个任务在同时进行，人们就想到了循环查询多个任务的完成状态，只要有任何一个任务完成，就去处理它。如果轮询不是进程的用户态，而是有人帮忙就好了。 那么这就是所谓的 “IO 多路复用” 。UNIX/Linux 下的 select、poll、epoll 就是干这个的（epoll 比 poll、select 效率高，做的事情是一样的）。

IO多路复用有两个特别的系统调用select、poll、epoll函数 。select调用是内核级别的，select轮询相对非阻塞的轮询的区别在于— 前者可以等待多个socket，能实现同时对多个IO端口进行监听 ，当其中任何一个socket的数据准好了， 就能返回进行可读 ， 然后进程再进行recvform系统调用，将数据由内核拷贝到用户进程，当然这个过程是阻塞的 。select或poll调用之后，会阻塞进程，与blocking IO阻塞不同在于， 此时的select不是等到socket数据全部到达再处理, 而是有了一部分数据就会调用用户进程来处理 。如何知道有一部分数据到达了呢？ 监视的事情交给了内核，内核负责数据到达的处理。也可以理解为"非阻塞"吧 。

I/O复用模型会用到select、poll、epoll函数，这几个函数也会使进程阻塞，但是和阻塞I/O所不同的的，这两个函数可以同时阻塞多个I/O操作 。而且可以同时对多个读操作，多个写操作的I/O函数进行检测，直到有数据可读或可写时（注意不是全部数据可读或可写），才真正调用I/O操作函数。

对于多路复用，也就是轮询多个socket。 多路复用既然可以处理多个IO，也就带来了新的问题，多个IO之间的顺序变得不确定了 ，当然也可以针对不同的编号。具体流程，如下图所示：

2.3.3 流程描述

IO multiplexing就是我们说的select，poll，epoll，有些地方也称这种IO方式为event driven IO。 select/epoll的好处就在于单个process就可以同时处理多个网络连接的IO 。它的基本原理就是select，poll，epoll这个function会不断的轮询所负责的所有socket，当某个socket有数据到达了，就通知用户进程。

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

上面的图和blocking IO的图其实并没有太大的不同，事实上，还更差一些。 因为这里需要使用两个system call (select 和 recvfrom)，而blocking IO只调用了一个system call (recvfrom) 。但是， 用select的优势在于它可以同时处理多个connection 。

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

在IO multiplexing Model中， 实际中，对于每一个socket，一般都设置成为non-blocking ，但是，如上图所示，整个用户的process其实是一直被block的。 只不过process是被select这个函数block，而不是被socket IO给block 。所以 IO多路复用是阻塞在select，epoll这样的系统调用之上，而没有阻塞在真正的I/O系统调用如recvfrom之上。

在I/O编程过程中， 当需要同时处理多个客户端接入请求时，可以利用多线程或者I/O多路复用技术进行处理 。I/O多路复用技术 通过把多个I/O的阻塞复用到同一个select的阻塞上，从而使得系统在单线程的情况下可以同时处理多个客户端请求 。与传统的多线程/多进程模型比， I/O多路复用的最大优势是系统开销小 ，系统不需要创建新的额外进程或者线程，也不需要维护这些进程和线程的运行，降底了系统的维护工作量，节省了系统资源，I/O多路复用的主要应用场景如下：

了解了前面三种IO模式，在用户进程进行系统调用的时候， 他们在等待数据到来的时候，处理的方式不一样，直接等待，轮询，select或poll轮询 ，两个阶段过程：

从整个IO过程来看，他们都是顺序执行的，因此可以归为同步模型(synchronous)。都是进程主动等待且向内核检查状态。【此句很重要！！！】

高并发的程序一般使用同步非阻塞方式而非多线程 + 同步阻塞方式 。要理解这一点，首先要扯到并发和并行的区别。比如去某部门办事需要依次去几个窗口， 办事大厅里的人数就是并发数，而窗口个数就是并行度 。也就是说 并发数是指同时进行的任务数（如同时服务的 HTTP 请求） ，而 并行数是可以同时工作的物理资源数量（如 CPU 核数） 。通过合理调度任务的不同阶段，并发数可以远远大于并行度，这就是区区几个 CPU 可以支持上万个用户并发请求的奥秘。在这种高并发的情况下，为每个任务（用户请求）创建一个进程或线程的开销非常大。 而同步非阻塞方式可以把多个 IO 请求丢到后台去，这就可以在一个进程里服务大量的并发 IO 请求 。

注意：IO多路复用是同步阻塞模型还是异步阻塞模型，在此给大家分析下：

2.4 信号驱动式IO（signal-driven IO）

信号驱动式I/O：首先我们允许Socket进行信号驱动IO,并安装一个信号处理函数，进程继续运行并不阻塞。当数据准备好时，进程会收到一个SIGIO信号，可以在信号处理函数中调用I/O操作函数处理数据。过程如下图所示：

2.5 异步非阻塞 IO（asynchronous IO）

2.5.1 场景描述

2.5.2 网络模型

相对于同步IO，异步IO不是顺序执行。 用户进程进行aio_read系统调用之后，无论内核数据是否准备好，都会直接返回给用户进程，然后用户态进程可以去做别的事情 。等到socket数据准备好了，内核直接复制数据给进程， 然后从内核向进程发送通知 。 IO两个阶段，进程都是非阻塞的 。

Linux提供了AIO库函数实现异步，但是用的很少。目前有很多开源的异步IO库，例如libevent、libev、libuv。异步过程如下图所示：

2.5.3 流程描述

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

在 Linux 中，通知的方式是 “信号”：

异步 API 说来轻巧，做来难，这主要是对 API 的实现者而言的。Linux 的异步 IO（AIO）支持是 2.6.22 才引入的，还有很多系统调用不支持异步 IO。Linux 的异步 IO 最初是为数据库设计的， 因此通过异步 IO 的读写操作不会被缓存或缓冲，这就无法利用操作系统的缓存与缓冲机制 。

很多人把 Linux 的 O_NONBLOCK 认为是异步方式，但事实上这是前面讲的同步非阻塞方式。 需要指出的是，虽然 Linux 上的 IO API 略显粗糙，但每种编程框架都有封装好的异步 IO 实现。操作系统少做事，把更多的自由留给用户，正是 UNIX 的设计哲学，也是 Linux 上编程框架百花齐放的一个原因。

从前面 IO 模型的分类中，我们可以看出 AIO 的动机：

IO多路复用除了需要阻塞之外， select 函数所提供的功能（异步阻塞 IO）与 AIO 类似 。不过， 它是对通知事件进行阻塞，而不是对 IO 调用进行阻塞 。

2.6 关于异步阻塞

有时我们的 API 只提供异步通知方式，例如在 node.js 里， 但业务逻辑需要的是做完一件事后做另一件事 ，例如数据库连接初始化后才能开始接受用户的 HTTP 请求。 这样的业务逻辑就需要调用者是以阻塞方式来工作 。

为了在异步环境里模拟 “顺序执行” 的效果，就需要把同步代码转换成异步形式，这称为 CPS（Continuation Passing Style）变换 。BYVoid 大神的  continuation.js 库就是一个 CPS 变换的工具。 用户只需用比较符合人类常理的同步方式书写代码，CPS 变换器会把它转换成层层嵌套的异步回调形式 。

另外一种使用阻塞方式的理由是降低响应延迟 。如果采用非阻塞方式，一个任务 A 被提交到后台，就开始做另一件事 B，但 B 还没做完，A 就完成了，这时要想让 A 的完成事件被尽快处理（比如 A 是个紧急事务），要么丢弃做到一半的 B，要么保存 B 的中间状态并切换回 A，任务的切换是需要时间的（不管是从磁盘载入到内存，还是从内存载入到高速缓存），这势必降低 A 的响应速度。 因此，对实时系统或者延迟敏感的事务，有时采用阻塞方式比非阻塞方式更好 。

3 五种IO模型总结

3.1 blocking和non-blocking区别

调用blocking IO会一直block住对应的进程直到操作完成，而non-blocking IO在kernel还准备数据的情况下会立刻返回。

3.2 synchronous IO和asynchronous IO区别

在说明synchronous IO和asynchronous IO的区别之前，需要先给出两者的定义。POSIX的定义是这样子的：

两者的区别就在于synchronous IO做”IO operation”的时候会将process阻塞 。按照这个定义，之前所述的blocking IO，non-blocking IO，IO multiplexing都属于synchronous IO。

有人会说，non-blocking IO并没有被block啊。这里有个非常“狡猾”的地方， 定义中所指的”IO operation”是指真实的IO操作 ，就是例子中的recvfrom这个system call。non-blocking IO在执行recvfrom这个system call的时候，如果kernel的数据没有准备好，这时候不会block进程。但是， 当kernel中数据准备好的时候，recvfrom会将数据从kernel拷贝到用户内存中，这个时候进程是被block了 ，在这段时间内，进程是被block的。

而asynchronous IO则不一样， 当进程发起IO 操作之后，就直接返回再也不理睬了，直到kernel发送一个信号，告诉进程说IO完成 。在这整个过程中，进程完全没有被block。

各个IO Model的比较如图所示：

通过上面的图片，可以发现non-blocking IO和asynchronous IO的区别还是很明显的。 在non-blocking IO中，虽然进程大部分时间都不会被block，但是它仍然要求进程去主动的check ，并且当数据准备完成以后，也需要进程主动的再次调用recvfrom来将数据拷贝到用户内存。而asynchronous IO则完全不同。 它就像是用户进程将整个IO操作交给了他人（kernel）完成，然后他人做完后发信号通知 。在此期间， 用户进程不需要去检查IO操作的状态，也不需要主动的去拷贝数据 。