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

1 概念阐明#

在进行解释之前，首先要阐明几个概念： 用户空间和内核空间 过程切换 过程的阻塞 文件描述符 缓存 IO 1.1 用户空间与内核空间##

当初操作系统都是采纳虚拟存储器，那么对32位操作系统而言，它的寻址空间（虚拟存储空间）为4G（2的32次方）。操作系统的外围是内核，独立于一般的应用程序，能够拜访受爱护的内存空间，也有拜访底层硬件设施的所有权限。为了保障用户过程不能间接操作内核（kernel），保障内核的平安，操作系统将虚拟空间划分为两局部，一部分为内核空间，一部分为用户空间。针对linux操作系统而言，将最高的1G字节（从虚拟地址0xC0000000到0xFFFFFFFF），供内核应用，称为内核空间，而将较低的3G字节（从虚拟地址0x00000000到0xBFFFFFFF），供各个过程应用，称为用户空间。

1.2 过程切换##

为了管制过程的执行，内核必须有能力挂起正在CPU上运行的过程，并复原以前挂起的某个过程的执行。这种行为被称为过程切换。因而能够说，任何过程都是在操作系统内核的反对下运行的，是与内核严密相干的。 从一个过程的运行转到另一个过程上运行，这个过程中通过上面这些变动：

  1. 保留处理机上下文，包含程序计数器和其余寄存器。
  2. 更新PCB信息。
  3. 把过程的PCB移入相应的队列，如就绪、在某事件阻塞等队列。
  4. 抉择另一个过程执行，并更新其PCB。
  5. 更新内存治理的数据结构。
  6. 复原处理机上下文。

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

须要上述材料或者Linux材料的请+qun832218493收费支付！

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操作产生时，它会经验两个阶段：

  1. 第一阶段：期待数据筹备 (Waiting for the data to be ready)。
  2. 第二阶段：将数据从内核拷贝到过程中 (Copying the data from the kernel to the process)。

对于socket流而言，

  1. 第一步：通常波及期待网络上的数据分组达到，而后被复制到内核的某个缓冲区。
  2. 第二步：把数据从内核缓冲区复制到利用过程缓冲区。

网络应用须要解决的无非就是两大类问题，网络IO，数据计算。绝对于后者，网络IO的提早，给利用带来的性能瓶颈大于后者。网络IO的模型大抵有如下几种：

  • 同步模型（synchronous IO）
  • 阻塞IO（bloking IO）
  • 非阻塞IO（non-blocking IO）
  • 多路复用IO（multiplexing IO）
  • 信号驱动式IO（signal-driven IO）
  • 异步IO（asynchronous 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的状态，从新运行起来。 所以，blocking IO的特点就是在IO执行的两个阶段都被block了。 长处：

  1. 可能及时返回数据，无提早；
  2. 对内核开发者来说这是省事了；

毛病：

  1. 对用户来说处于期待就要付出性能的代价了；

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，那么它马上就将数据拷贝到了用户内存，而后返回。 所以，nonblocking IO的特点是用户过程须要一直的被动询问kernel数据好了没有。 同步非阻塞形式相比同步阻塞形式： 长处：可能在期待工作实现的工夫里干其余活了（包含提交其余工作，也就是 “后盾” 能够有多个工作在同时执行）。 毛病：工作实现的响应提早增大了，因为每过一段时间才去轮询一次read操作，而工作可能在两次轮询之间的任意工夫实现。这会导致整体数据吞吐量的升高。 2.3 IO 多路复用（ IO multiplexing）##

2.3.1 场景形容### 与第二个计划差不多，餐厅装置了电子屏幕用来显示点餐的状态，这样我和女友逛街一会，回来就不必去询问服务员了，间接看电子屏幕就能够了。这样每个人的餐是否好了，都间接看电子屏幕就能够了，这就是典型的IO多路复用。 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拷贝到用户过程。 多路复用的特点是通过一种机制一个过程能同时期待IO文件描述符，内核监督这些文件描述符（套接字描述符），其中的任意一个进入读就绪状态，select， poll，epoll函数就能够返回。对于监督的形式，又能够分为 select， poll， epoll三种形式。 下面的图和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多路复用是同步阻塞模型还是异步阻塞模型，在此给大家剖析下： 此处依然不太分明的，强烈建议大家在细究《聊聊同步、异步、阻塞与非阻塞》中讲同步与异步的根本性区别，同步是须要被动期待音讯告诉，而异步则是被动接管音讯告诉，通过回调、告诉、状态等形式来被动获取音讯。IO多路复用在阻塞到select阶段时，用户过程是被动期待并调用select函数获取数据就绪状态音讯，并且其过程状态为阻塞。所以，把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 中，告诉的形式是 “信号”：

如果这个过程正在用户态忙着做别的事（例如在计算两个矩阵的乘积），那就强行打断之，调用当时注册的信号处理函数，这个函数能够决定何时以及如何解决这个异步工作。因为信号处理函数是忽然闯进来的，因而跟中断处理程序一样，有很多事件是不能做的，因而保险起见，个别是把事件 “注销” 一下放进队列，而后返回该过程原来在做的事。

如果这个过程正在内核态忙着做别的事，例如以同步阻塞形式读写磁盘，那就只好把这个告诉挂起来了，等到内核态的事件忙完了，快要回到用户态的时候，再触发信号告诉。 如果这个过程当初被挂起了，例如无事可做 sleep 了，那就把这个过程唤醒，下次有 CPU 闲暇的时候，就会调度到这个过程，触发信号告诉。 异步 API 说来笨重，做来难，这次要是对 API 的实现者而言的。Linux 的异步 IO（AIO）反对是 2.6.22 才引入的，还有很多零碎调用不反对异步 IO。Linux 的异步 IO 最后是为数据库设计的，因而通过异步 IO 的读写操作不会被缓存或缓冲，这就无奈利用操作系统的缓存与缓冲机制。

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

从后面 IO 模型的分类中，咱们能够看出 AIO 的动机： 同步阻塞模型须要在 IO 操作开始时阻塞应用程序。这意味着不可能同时重叠进行解决和 IO 操作。 同步非阻塞模型容许解决和 IO 操作重叠进行，然而这须要应用程序依据重现的规定来查看 IO 操作的状态。 这样就剩下异步非阻塞 IO 了，它容许解决和 IO 操作重叠进行，包含 IO 操作实现的告诉。 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的定义是这样子的： A synchronous I/O operation causes the requesting process to be blocked until that I/O operation completes; An asynchronous I/O operation does not cause the requesting process to be blocked; 两者的区别就在于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操作的状态，也不须要被动的去拷贝数据。