IO复用,AIO,BIO,NIO,同步，异步，阻塞和非阻塞 区别(百度)

还有一篇：聊聊BIO，NIO和AIO (1)

若是面试问到IO操做，这篇文章提到的问题，基本是必问，百度的面试官问我三个问题

(1)什么是NIO(Non-blocked IO),AIO,BIO

(2) java IO 与 NIO(New IO)的区别

(3)select 与 epoll,poll区别

我胡乱说了一气，本身边说边以为完蛋了。果真，二面没过，很简单的问题，回来后赶忙做了总结：

1、什么是socket？什么是I/O操做？ 

咱们都知道unix(like)世界里，一切皆文件，而文件是什么呢？文件就是一串二进制流而已，无论socket,仍是FIFO、管道、终端，对咱们来讲，一切都是文件，一切都是流。在信息 交换的过程当中，咱们都是对这些流进行数据的收发操做，简称为I/O操做(input and output)，往流中读出数据，系统调用read，写入数据，系统调用write。不过话说回来了 ，计算机里有这么多的流，我怎么知道要操做哪一个流呢？对，就是文件描述符，即一般所说的fd，一个fd就是一个整数，因此，对这个整数的操做，就是对这个文件（流）的操做。咱们建立一个socket,经过系统调用会返回一个文件描述符，那么剩下对socket的操做就会转化为对这个描述符的操做。不能不说这又是一种分层和抽象的思想。

2、同步异步，阻塞非阻塞区别联系

    实际上同步与异步是针对应用程序与内核的交互而言的。同步过程当中进程触发IO操做并等待(也就是咱们说的阻塞)或者轮询的去查看IO操做(也就是咱们说的非阻塞)是否完成。 异步过程当中进程触发IO操做之后，直接返回，作本身的事情，IO交给内核来处理，完成后内核通知进程IO完成。

同步和异步针对应用程序来讲，关注的是程序中间的协做关系；阻塞与非阻塞更关注的是单个进程的执行状态。

同步有阻塞和非阻塞之分，异步没有，它必定是非阻塞的。

阻塞、非阻塞、多路IO复用，都是同步IO，异步一定是非阻塞的，因此不存在异步阻塞和异步非阻塞的说法。真正的异步IO须要CPU的深度参与。换句话说，只有用户线程在操做IO的时候根本不去考虑IO的执行所有都交给CPU去完成，而本身只等待一个完成信号的时候，才是真正的异步IO。因此，拉一个子线程去轮询、去死循环，或者使用select、poll、epool，都不是异步。

同步：执行一个操做以后，进程触发IO操做并等待(也就是咱们说的阻塞)或者轮询的去查看IO操做(也就是咱们说的非阻塞)是否完成，等待结果，而后才继续执行后续的操做。

异步：执行一个操做后，能够去执行其余的操做，而后等待通知再回来执行刚才没执行完的操做。

阻塞：进程给CPU传达一个任务以后，一直等待CPU处理完成，而后才执行后面的操做。

非阻塞：进程给CPU传达任我后，继续处理后续的操做，隔断时间再来询问以前的操做是否完成。这样的过程其实也叫轮询。

我认为， 同步与异步的根本区别是：

(1) 这是 BIO，同步阻塞的模型，下面也有，

由上面的图能够看出，IO读分为两部分，(a)是数据经过网关到达内核，内核准备好数据，(b)数据从内核缓存写入用户缓存。

同步：无论是BIO,NIO,仍是IO多路复用，第二步数据从内核缓存写入用户缓存必定是由 用户线程自行读取数据，处理数据。

异步：第二步数据是内核写入的，并放在了用户线程指定的缓存区，写入完毕后通知用户线程。

 

2、阻塞？

什么是程序的阻塞呢？想象这种情形，好比你等快递，但快递一直没来，你会怎么作？有两种方式：

• 快递没来，我能够先去睡觉，而后快递来了给我打电话叫我去取就好了。
• 快递没来，我就不停的给快递打电话说：擦，怎么还没来，给老子快点，直到快递来。

很显然，你没法忍受第二种方式，不只耽搁本身的时间，也会让快递很想打你。
而在计算机世界，这两种情形就对应阻塞和非阻塞忙轮询。

• 非阻塞忙轮询：数据没来，进程就不停的去检测数据，直到数据来。
• 阻塞：数据没来，啥都不作，直到数据来了，才进行下一步的处理。

先说说阻塞，由于一个线程只能处理一个套接字的I/O事件，若是想同时处理多个，能够利用非阻塞忙轮询的方式,伪代码以下： 

while true  
{  
    for i in stream[]  
    {  
        if i has data  
        read until unavailable  
    }  
}  

咱们只要把全部流从头至尾查询一遍，就能够处理多个流了，但这样作很很差，由于若是全部的流都没有I/O事件，白白浪费CPU时间片。正若有一位科学家所说，计算机全部的问题均可以增长一个中间层来解决，一样，为了不这里cpu的空转，咱们不让这个线程亲自去检查流中是否有事件，而是引进了一个代理(一开始是select,后来是poll)，这个代理很牛，它能够同时观察许多流的I/O事件，若是没有事件，代理就阻塞，线程就不会挨个挨个去轮询了，伪代码以下：  

while true  
{  
    select(streams[]) //这一步死在这里，知道有一个流有I/O事件时，才往下执行  
    for i in streams[]  
    {  
        if i has data  
        read until unavailable  
    }  
}  

 可是依然有个问题，咱们从select那里仅仅知道了，有I/O事件发生了，却并不知道是哪那几个流（可能有一个，多个，甚至所有），咱们只能无差异轮询全部流，找出能读出数据，或者写入数据的流，对他们进行操做。因此select具备O(n)的无差异轮询复杂度，同时处理的流越多，无差异轮询时间就越长。

epoll能够理解为event poll，不一样于忙轮询和无差异轮询，epoll会把哪一个流发生了怎样的I/O事件通知咱们。因此咱们说epoll其实是事件驱动（每一个事件关联上fd）的，此时咱们对这些流的操做都是有意义的。（复杂度下降到了O(1)）伪代码以下：

while true  
{  
    active_stream[] = epoll_wait(epollfd)  
    for i in active_stream[]  
    {  
        read or write till  
    }  
}  

能够看到，select和epoll最大的区别就是：select只是告诉你必定数目的流有事件了，至于哪一个流有事件，还得你一个一个地去轮询，而epoll会把发生的事件告诉你，经过发生的事件，就天然而然定位到哪一个流了。不能不说epoll跟select相比，是质的飞跃，我以为这也是一种牺牲空间，换取时间的思想，毕竟如今硬件愈来愈便宜了。

更详细的Select,poll,epoll 请参考：select、poll、epoll之间的区别(搜狗面试)

3、I/O多路复用

好了，咱们讲了这么多，再来总结一下，到底什么是I/O多路复用。
先讲一下I/O模型：
首先，输入操做通常包含两个步骤：

1. 等待数据准备好（waiting for data to be ready）。对于一个套接口上的操做，这一步骤关系到数据从网络到达，并将其复制到内核的某个缓冲区。
2. 将数据从内核缓冲区复制到进程缓冲区（copying the data from the kernel to the process）。

其次了解一下经常使用的3种I/O模型：

一、阻塞I/O模型(BIO)

最普遍的模型是阻塞I/O模型，默认状况下，全部套接口都是阻塞的。 进程调用recvfrom系统调用，整个过程是阻塞的，直到数据复制到进程缓冲区时才返回（固然，系统调用被中断也会返回）。

二、非阻塞I/O模型(NIO)

当咱们把一个套接口设置为非阻塞时，就是在告诉内核，当请求的I/O操做没法完成时，不要将进程睡眠，而是返回一个错误。当数据没有准备好时，内核当即返回EWOULDBLOCK错误，第四次调用系统调用时，数据已经存在，这时将数据复制到进程缓冲区中。这其中有一个操做时轮询（polling）。

三、I/O复用模型

此模型用到select和poll函数，这两个函数也会使进程阻塞，select先阻塞，有活动套接字才返回，可是和阻塞I/O不一样的是，这两个函数能够同时阻塞多个I/O操做，并且能够同时对多个读操做，多个写操做的I/O函数进行检测，直到有数据可读或可写（就是监听多个socket）。select被调用后，进程会被阻塞，内核监视全部select负责的socket，当有任何一个socket的数据准备好了，select就会返回套接字可读，咱们就能够调用recvfrom处理数据。
正由于阻塞I/O只能阻塞一个I/O操做，而I/O复用模型可以阻塞多个I/O操做，因此才叫作多路复用。

 

四、信号驱动I/O模型（signal driven I/O， SIGIO）

　　首先咱们容许套接口进行信号驱动I/O,并安装一个信号处理函数，进程继续运行并不阻塞。当数据准备好时，进程会收到一个SIGIO信号，能够在信号处理函数中调用I/O操做函数处理数据。当数据报准备好读取时，内核就为该进程产生一个SIGIO信号。咱们随后既能够在信号处理函数中调用recvfrom读取数据报，并通知主循环数据已准备好待处理，也能够当即通知主循环，让它来读取数据报。不管如何处理SIGIO信号，这种模型的优点在于等待数据报到达(第一阶段)期间，进程能够继续执行，不被阻塞。免去了select的阻塞与轮询，当有活跃套接字时，由注册的handler处理。

 

五、异步I/O模型(AIO, asynchronous I/O)

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

　　这个模型工做机制是：告诉内核启动某个操做，并让内核在整个操做(包括第二阶段，即将数据从内核拷贝到进程缓冲区中)完成后通知咱们。

这种模型和前一种模型区别在于：信号驱动I/O是由内核通知咱们什么时候能够启动一个I/O操做，而异步I/O模型是由内核通知咱们I/O操做什么时候完成。

高性能IO模型浅析  

服务器端编程常常须要构造高性能的IO模型，常见的IO模型有四种：

（1）同步阻塞IO（Blocking IO）：即传统的IO模型。

（2）同步非阻塞IO（Non-blocking IO）：默认建立的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。注意这里所说的NIO并不是Java的NIO（New IO）库。

（3）IO多路复用（IO Multiplexing）：即经典的Reactor设计模式，Java中的Selector和Linux中的epoll都是这种模型。

（4）异步IO（Asynchronous IO）：即经典的Proactor设计模式，也称为异步非阻塞IO。 

为了方便描述，咱们统一使用IO的读操做做为示例。 

1、同步阻塞IO 

同步阻塞IO模型是最简单的IO模型，用户线程在内核进行IO操做时被阻塞。

图1 同步阻塞IO

如图1所示，用户线程经过系统调用read发起IO读操做，由用户空间转到内核空间。内核等到数据包到达后，而后将接收的数据拷贝到用户空间，完成read操做。

用户线程使用同步阻塞IO模型的伪代码描述为：

{

read(socket, buffer);

process(buffer);

}

 即用户须要等待read将socket中的数据读取到buffer后，才继续处理接收的数据。整个IO请求的过程当中，用户线程是被阻塞的，这致使用户在发起IO请求时，不能作任何事情，对CPU的资源利用率不够。 

2、同步非阻塞IO 

同步非阻塞IO是在同步阻塞IO的基础上，将socket设置为NONBLOCK。这样作用户线程能够在发起IO请求后能够当即返回。

 

图2 同步非阻塞IO

如图2所示，因为socket是非阻塞的方式，所以用户线程发起IO请求时当即返回。但并未读取到任何数据，用户线程须要不断地发起IO请求，直到数据到达后，才真正读取到数据，继续执行。

用户线程使用同步非阻塞IO模型的伪代码描述为：

{

while(read(socket, buffer) != SUCCESS)

;

process(buffer);

}

 

即用户须要不断地调用read，尝试读取socket中的数据，直到读取成功后，才继续处理接收的数据。整个IO请求的过程当中，虽然用户线程每次发起IO请求后能够当即返回，可是为了等到数据，仍须要不断地轮询、重复请求，消耗了大量的CPU的资源。通常不多直接使用这种模型，而是在其余IO模型中使用非阻塞IO这一特性。

 

3、IO多路复用

IO多路复用模型是创建在内核提供的多路分离函数select基础之上的，使用select函数能够避免同步非阻塞IO模型中轮询等待的问题。

图3 多路分离函数select

如图3所示，用户首先将须要进行IO操做的socket添加到select中，而后阻塞等待select系统调用返回。当数据到达时，socket被激活，select函数返回。用户线程正式发起read请求，读取数据并继续执行。

从流程上来看，使用select函数进行IO请求和同步阻塞模型没有太大的区别，甚至还多了添加监视socket，以及调用select函数的额外操做，效率更差。可是，使用select之后最大的优点是用户能够在一个线程内同时处理多个socket的IO请求。用户能够注册多个socket，而后不断地调用select读取被激活的socket，便可达到在同一个线程内同时处理多个IO请求的目的。而在同步阻塞模型中，必须经过多线程的方式才能达到这个目的。

用户线程使用select函数的伪代码描述为：

{

select(socket);

while(1) {

sockets = select();

for(socket in sockets) {

if(can_read(socket)) {

read(socket, buffer);

process(buffer);

}

}

}

}

 其中while循环前将socket添加到select监视中，而后在while内一直调用select获取被激活的socket，一旦socket可读，便调用read函数将socket中的数据读取出来。 

然而，使用select函数的优势并不只限于此。虽然上述方式容许单线程内处理多个IO请求，可是每一个IO请求的过程仍是阻塞的（在select函数上阻塞），平均时间甚至比同步阻塞IO模型还要长。若是用户线程只注册本身感兴趣的socket或者IO请求，而后去作本身的事情，等到数据到来时再进行处理，则能够提升CPU的利用率。

IO多路复用模型使用了Reactor设计模式实现了这一机制。

图4 Reactor设计模式

如图4所示，EventHandler抽象类表示IO事件处理器，它拥有IO文件句柄Handle（经过get_handle获取），以及对Handle的操做handle_event（读/写等）。继承于EventHandler的子类能够对事件处理器的行为进行定制。Reactor类用于管理EventHandler（注册、删除等），并使用handle_events实现事件循环，不断调用同步事件多路分离器（通常是内核）的多路分离函数select，只要某个文件句柄被激活（可读/写等），select就返回（阻塞），handle_events就会调用与文件句柄关联的事件处理器的handle_event进行相关操做。

图5 IO多路复用

如图5所示，经过Reactor的方式，能够将用户线程轮询IO操做状态的工做统一交给handle_events事件循环进行处理。用户线程注册事件处理器以后能够继续执行作其余的工做（异步），而Reactor线程负责调用内核的select函数检查socket状态。当有socket被激活时，则通知相应的用户线程（或执行用户线程的回调函数），执行handle_event进行数据读取、处理的工做。因为select函数是阻塞的，所以多路IO复用模型也被称为异步阻塞IO模型。注意，这里的所说的阻塞是指select函数执行时线程被阻塞，而不是指socket。通常在使用IO多路复用模型时，socket都是设置为NONBLOCK的，不过这并不会产生影响，由于用户发起IO请求时，数据已经到达了，用户线程必定不会被阻塞。

用户线程使用IO多路复用模型的伪代码描述为：

void UserEventHandler::handle_event() {

if(can_read(socket)) {

read(socket, buffer);

process(buffer);

}

}

 

{

Reactor.register(new UserEventHandler(socket));

}

 

用户须要重写EventHandler的handle_event函数进行读取数据、处理数据的工做，用户线程只须要将本身的EventHandler注册到Reactor便可。Reactor中handle_events事件循环的伪代码大体以下。

Reactor::handle_events() {

while(1) {

sockets = select();

for(socket in sockets) {

get_event_handler(socket).handle_event();

}

}

}

事件循环不断地调用select获取被激活的socket，而后根据获取socket对应的EventHandler，执行器handle_event函数便可。

IO多路复用是最常使用的IO模型，可是其异步程度还不够“完全”，由于它使用了会阻塞线程的select系统调用。所以IO多路复用只能称为异步阻塞IO，而非真正的异步IO。 

4、异步IO 

“真正”的异步IO须要操做系统更强的支持。在IO多路复用模型中，事件循环将文件句柄的状态事件通知给用户线程，由用户线程自行读取数据、处理数据。而在异步IO模型中，当用户线程收到通知时，数据已经被内核读取完毕，并放在了用户线程指定的缓冲区内，内核在IO完成后通知用户线程直接使用便可。

异步IO模型使用了Proactor设计模式实现了这一机制。

图6 Proactor设计模式

如图6，Proactor模式和Reactor模式在结构上比较类似，不过在用户（Client）使用方式上差异较大。Reactor模式中，用户线程经过向Reactor对象注册感兴趣的事件监听，而后事件触发时调用事件处理函数。而Proactor模式中，用户线程将AsynchronousOperation（读/写等）、Proactor以及操做完成时的CompletionHandler注册到AsynchronousOperationProcessor。AsynchronousOperationProcessor使用Facade模式提供了一组异步操做API（读/写等）供用户使用，当用户线程调用异步API后，便继续执行本身的任务。AsynchronousOperationProcessor 会开启独立的内核线程执行异步操做，实现真正的异步。当异步IO操做完成时，AsynchronousOperationProcessor将用户线程与AsynchronousOperation一块儿注册的Proactor和CompletionHandler取出，而后将CompletionHandler与IO操做的结果数据一块儿转发给Proactor，Proactor负责回调每个异步操做的事件完成处理函数handle_event。虽然Proactor模式中每一个异步操做均可以绑定一个Proactor对象，可是通常在操做系统中，Proactor被实现为Singleton模式，以便于集中化分发操做完成事件。

图7 异步IO

如图7所示，异步IO模型中，用户线程直接使用内核提供的异步IO API发起read请求，且发起后当即返回，继续执行用户线程代码。不过此时用户线程已经将调用的AsynchronousOperation和CompletionHandler注册到内核，而后操做系统开启独立的内核线程去处理IO操做。当read请求的数据到达时，由内核负责读取socket中的数据，并写入用户指定的缓冲区中。最后内核将read的数据和用户线程注册的CompletionHandler分发给内部Proactor，Proactor将IO完成的信息通知给用户线程（通常经过调用用户线程注册的完成事件处理函数），完成异步IO。

用户线程使用异步IO模型的伪代码描述为：

void UserCompletionHandler::handle_event(buffer) {

process(buffer);

}

 

{

aio_read(socket, new UserCompletionHandler);

}

 用户须要重写CompletionHandler的handle_event函数进行处理数据的工做，参数buffer表示Proactor已经准备好的数据，用户线程直接调用内核提供的异步IO API，并将重写的CompletionHandler注册便可。

相比于IO多路复用模型，异步IO并不十分经常使用，很多高性能并发服务程序使用IO多路复用模型+多线程任务处理的架构基本能够知足需求。何况目前操做系统对异步IO的支持并不是特别完善，更多的是采用IO多路复用模型模拟异步IO的方式（IO事件触发时不直接通知用户线程，而是将数据读写完毕后放到用户指定的缓冲区中）。Java7以后已经支持了异步IO，感兴趣的读者能够尝试使用。 

参考：高性能IO模型浅析

参考：什么是IO多路复用，理解IO多路复用

参考：关于同步、异步与阻塞、非阻塞的理解