网络编程的I/O模式

5种类UNIX下可用的I/O模型：

·同步阻塞I/O（blocking IO）： 即传统的IO模式。

·同步非阻塞I/O（nonblocking IO）：默认创建的socket都是阻塞的，非阻塞IO要求socket 被设置成NONBLOCK。

·I/O复用（IO multiplexing）： 即经典的Reactor设计模式，有时也称异步阻塞IO， Linux中的epoll，Java中的selector都是这种模型。

·信号驱动式（signal driven IO）：

·异步I/O（asynchronous IO）： 即经典的Proactor模式，也成称异步非阻塞IO。

POSIX: Portable Operating System Interface of UNIX—可移植操作系统接口。

I/O发生时涉及到的对象和步骤：

对于一个网络编程I/O（以read为例），它会涉及两个系统对象，一个是调用这个I/O的procss或thread，另一个是系统内核kernal，当一个操作发生时会经历两个步骤：

1.等待数据准备

2.将数据从内核拷贝到进程

所以I/O模型的区别就在这两点

Blocking IO

linux下默认的所以socket都是blocking，一个典型的读操作流程：



当用户线程调用read发起IO读操作，将由用户空间转到内核空间，第一步通常涉及等待数据从网络中到达。当所有数据到达时，它被复制到内核中的莫个缓冲区。第二步把数据从内核缓冲区复制到应用程序缓冲区。

当用户线程调用read发起IO读操作，将由用户空间转到内核空间，第一步通常涉及等待数据从网络中到达。当所有数据到达时，它被复制到内核中的莫个缓冲区。第二步把数据从内核缓冲区复制到应用程序缓冲区。

{
read(socket, buffer);
process(buffer);
}

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

Nonblocking IO

同步非阻塞IO是在同步阻塞IO的基础上，将socket设置为NONBLOCK。这样用户发起IO请求后可以立即返回。



由于socket是非阻塞的，因此用户线程发起IO请求时立即返回。但未必读取任何数据，用户线程需要不断的发起IO请求，直到数据到达后，才能真正读取数据，继续执行。

{
while( read( socket ,buffer)  !=  SUCCESS)
;
process(buffer);
}

即用户需要不断的调用read，尝试读取socket中数据，直到读取完成后，才能继续处理接收的数据。整个IO请求中，虽然用户线程每次发起IO请求后可以立即返回，但是返回的并不是用户真正需要的数据，往往需要不断的轮询重复请求，同样消耗了大量的CPU资源。

IO multiplexing

IO多路复用模型建立在系统提供的多路分离函数select基础之上，使用select函数，可以避免同步非阻塞IO模型中轮询等待的问题。



用户首先将需要进行IO操作的socket添加到select中，然后阻塞等待select系统调用返回。当数据到达，socket被激活，select返回。用户线程正式发起read请求，读取数据继续执行。

从流程上看，使用select函数进行IO请求和同步阻塞没有什么区别，甚至还多了添加socket以及select系统调用的额外操作效率更差。但是，使用select的最大优势是，用户可以在一个线程同时处理多个socket的IO请求。用户可以注册多个socket，然后不断调用select读取被激活的socket，即可达到同一线程内同时处理多个IO请求的目的。而在同步阻塞的模型中，必须通过多进程方式才能达到。

{
select(socket);
while(1)
{
sockets = select();
for(socket  in  sockets)
{
if(can_read(socket))
{
read(socket, buffer);
process(buff);
}
}
}
}

其中while之前将socket添加到select监视中，然后进入while内一直调用select获取被激活的socket，一旦socket可读，便调用read将socket中数据读取出来。

然而，使用select的优点并不仅限于此。虽然上述方式允许单线程内处理多个IO请求，但是每个IO请求的过程还是阻塞（在select上阻塞），平均时间甚至比同步阻塞IO模型还要长。如何用户线程只注册自己感兴趣的socket或者IO请求，然后去做自己的事情，等到数据来时在处理，则可以提高CPU的利用率。

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



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



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

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

void UserEvnetHandler::handle_event(){
if(can_read(socket)){
read(socket,  buffer);
process(buffer);
}
{
Reactor.register(new  UserEventHandler(socket));
}

用户需要重写EventHandler的handle_event函数进行读取数据，处理数据的工作，用户线程只需要将自己的EventHandle注册到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模型，但是其异步程度还不够“彻底”，因为它使用了会阻塞线程的selcet系统调用。因此IO多路复用只能称为异步阻塞IO，而非真正的异步IO。

asynchronous IO

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

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



Proactor和Reactor模式在结构上比较相似，不过在用户使用方式上差别较大。Reactor模式中，用户线程通过向Reactor对象注册感兴趣的事件监听，然后事件触发时调用事件处理函数。而Proactor模式中，用户线程将AsynchronousOperation（读写等），Proactor以及操作完成时的CompletionHandler注册到AsynchronosOperactionProcessor。AsynchronosOperactionProcessor使用Facade模式提供了一组异步操作API（读写等）供用户使用，当用户线程调用异步API后，便继续执行自己的任务，AsynchronosOperactionProcessor会开启独立的内核线程执行异步操作，实现真正的异步。当异步操作完成时，AsynchronosOperactionProcessor将用户线程与AsynchronosOperaction一起注册的Proactor和CompletionHandler 取出，然后将CompletionHandler与IO操作的结果数据一起转发给Proactor，Proactor负责回调每一个异步操作的事件完成时处理的函数handle_event。

虽然Proactor模式在每个异步操作都可以绑定一个Proactor对象，但是一般在操作系统中，Proactor被实现为Singleton模式，以便于集中化分发操作完成事件。



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

用户线程使用异步IO模式的伪代码：

void  UserCompletionHandler：：handle_event(buffer){
process(buffer);
}
{
aio_read(socket,new UserCompletionHandler);
}

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

相比于IO多路复用模型，异步IO并不十分常用，不少高性能并发服务器程序使用IO多路复用模式+多线程任务处理的架构基本可以满足需求。况且目前OS对异步IO的支持非特别完善，更多的是采用IO多路复用模型模拟异步IO的方式（IO事件触发时不直接通知用户线程，而是将数据读完后放到用户指定的缓冲区）。