异步非阻塞高性能IO模型浅析

约定不等于承诺〃 2022-08-14 00:57 157阅读 0赞

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

1.  同步阻塞IO（Blocking IO）：即传统的IO模型
2.  同步非阻塞IO（Non-blocking IO）：默认创建的socket都是阻塞的，非阻塞IO要求socket被设置为NONBLOCK。在Java领域，也称为New I/O
3.  IO多路复用（IO Multiplexing）：即经典的Reactor设计模式，有时也称为异步阻塞IO，Java中的Selector和Linux中的epoll都是这种模型
4.  异步IO（Asynchronous IO）：即经典的Proactor设计模式，也称为异步非阻塞IO

### **1.同步** or **异步** ###

主要是描述的是**用户线程与内核**的**交互方式**，

同步：指**用户线程发起**IO请求后需要等待或者轮询内核IO操作**完成后才能继续执行**

异步：指**用户线程发起**IO请求后仍继续执行，当内核IO操作完成后会**通知用户线程**，或者**调用用户**线程注册的**回调函数**

### 2.阻塞 or 非阻塞 ###

主要描述的是用户线程调用内核之后**是否立即返回**

阻塞：IO操作需要**彻底完成后**才返回到用户空间

非阻塞：IO操作被调用后**立即返回**给用户一个状态值，无需等到IO操作彻底完成

### 3.经典IO模型对比图 ###

如果你能看懂8成，后面的内容就可以一扫而过

**第一阶段**：等待数据就绪；

**第二阶段**：将已就绪的数据从内核缓冲区拷贝到用户空间；

试想为何不能从网卡读到的数据直接返回给用户空间呢？

因为从网卡读到的数据不一定是完整的（可能断断续续的过来），读取完结后只需要一次的系统中断就可以把全部数据返回给用户，这样就能避免频繁的中断产生。

![70][]

### **4.**同步阻塞IO ###

**![Center][]**

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

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

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

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

### 5.同步非阻塞IO ###

在同步阻塞IO的基础上，将socket设置为NONBLOCK（在发起IO请求后可以立即返回）

**![Center 1][]**

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

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

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

即用户需要不断地调用read，尝试读取socket中的数据，直到读取成功后，才继续处理接收的数据。整个IO请求的过程中，虽然用户线程每次发起IO请求后可以立即返回，但是为了等到数据，仍需要**不断地轮询**、**重复请求**，**消耗了大量的CPU的资源**。一般很少直接使用这种模型。

### 6.IO多路复用 ###

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

![Center 2][]

如上图所示，用户首先将需要进行IO操作的socket添加到select中（为了监视），然后阻塞等待select系统调用返回。当数据到达时，socket被激活，select函数返回。用户线程正式发起read请求，读取数据并继续执行。使用select以后最大的优势是用户可以在**同一个线程内同时处理多个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函数将数据读取出来**。

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

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

![Center 3][]

EventHandler抽象类：表示IO事件处理器，它拥有IO文件句柄Handle（通过get\_handle获取），以及对Handle的操作handle\_event（读/写等）。继承于EventHandler的子类可以对事件处理器的行为进行定制。

Reactor类：用于管理EventHandler（注册、删除等），并使用handle\_events实现事件循环，不断调用同步事件多路分离器（一般是内核）的多路分离函数select，只要某个文件句柄被激活（可读/写等），select就返回（阻塞），handle\_events就会调用与文件句柄关联的事件处理器的handle\_event进行相关操作。

![Center 4][]

如上图所示，通过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。

### 7.异步IO ###

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

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

**![Center 5][]**

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模式**，以便于集中化分发操作完成事件**。**

**![Center 6][]**

如上图所示，异步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模型，提高服务质量。希望本文对你有所帮助。

[70]: /images/20220810/9bed9d7b23244041baa4e324fd8800fd.png
[Center]: /images/20220810/1e7f577a9f2c4ef9a0839034e731cd4e.png
[Center 1]: /images/20220810/0c6c68a3b4fd485d83154922c4649aae.png
[Center 2]: /images/20220810/8b96f0805d4d42af8981c59252afe2c2.png
[Center 3]: /images/20220810/69b2870c3e89461ab94b3f5378b493d4.png
[Center 4]: /images/20220810/ee1389ab7bf4432b993ef4feec40537d.png
[Center 5]: /images/20220810/ec62519c0f054490839c702dc71608df.png
[Center 6]: /images/20220810/c408c2e236ea42288a4f42ce1c754dee.png