3、五种网络I/O模型

1、什么是IO
　　我们都知道在Unix/Linux世界里，一切皆文件。而文件是什么呢？文件就是一串二进制流而已，不管socket、FIFO、管道、终端还是其他什么，对我们来说，一切都是文件，一切都是流。在信息交换的过程中，我们都是对这些流进行数据的读写操作，简称为I/O操作(input and output)。

　　那么计算机里有这么多的流，怎么知道要操作哪个流呢？这时就需要文件描述符，即通常所说的fd。一个fd就是一个整数，所以对这个整数的操作就是对这个文件（流）的操作，我们创建一个socket，通过系统调用会返回一个文件描述符，那么剩下对socket的操作就会转化为对这个描述符的操作，不能不说这又是一种分层和抽象的思想。

2、IO交互
　　通常用户进程中的一个完整IO分为两阶段：

 

 

 

 

 

 

 

 

用户空间 <-----> 内核空间、内核空间 <-----> 设备空间

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

　　内核空间中存放的是内核代码和数据，而进程的用户空间中存放的是用户程序的代码和数据。

　　不管是内核空间还是用户空间，它们都处于虚拟内存中。

　　Linux使用两级保护机制：0级供内核使用，3级供用户程序使用

　　操作系统和驱动程序运行在内核空间，应用程序运行在用户空间。两者不能简单地使用指针传递数据，因为Linux使用的虚拟内存机制，其必须通过系统调用请求kernel来协助完成IO动作。内核会为每个IO设备维护一个缓冲区，用户空间的数据可能被换出，当内核空间使用用户空间指针时，对应的数据可能不在内存中。

　　对于一个输入操作来说，进程IO系统调用后，内核会先看缓冲区中有没有相应的缓存数据，没有的话再到设备中读取。因为设备IO一般速度较慢，需要等待，内核缓冲区有数据则直接复制到进程空间。所以，对于一个网络输入操作通常包括两个不同阶段：

　　（1）等待网络数据到达网卡 –> 读取到内核缓冲区
　　（2）从内核缓冲区复制数据 –> 用户空间

　　IO有内存IO、网络IO和磁盘IO三种，通常我们说的IO指的是后两者。

3、POSIX

　　POSIX是Portable Operating System Interface（移植操作系统接口）的缩写，它是IEEE为提高不同操作系统的兼容性和应用程序的可移植性而制定的一套标准，其正式称呼为IEEE Std 1003，而国际标准名称为ISO/IEC 9945。此标准源于一个大约开始于1985年的项目。POSIX这个名称是由理查德·斯托曼（RMS）应IEEE的要求而提议的一个易于记忆的名称。它基本上是Portable Operating System Interface（可移植操作系统接口）的缩写，而X则表明其对Unix API的传承。

　　POSIX它表示可移植操作系统接口（Portable Operating System Interface of UNIX，缩写为 POSIX ），POSIX标准定义了操作系统应该为应用程序提供的接口标准。

　　POSIX标准意在期望获得源代码级别的软件可移植性。换句话说，为一个POSIX兼容的操作系统编写的程序，应该可以在任何其它的POSIX操作系统（即使是来自另一个厂商）上编译执行。

　　Unix设计哲学中有这样子的一条“舍高效率而取可移植性“，而POSIX标准就源自于Unix下的依赖C语言的一系列标准服务。

　　POSIX定义了操作系统应该为应用程序提供的接口。这一标准带来的好处就是在一个POSIX兼容的操作系统编写的符合其标准的应用程序可以直接在其他POSIX支持的操作系统中无需修改而能够直接编译运行。当然这很容易让人想到那些依靠虚拟机支持的跨平台开发语言的跨平台特性。例如JAVA，可以说它的跨平台能力是靠牺牲性能而换取来的。但遵守POSIX标准开发的程序在支持POSIX标准的操作系统间运行是不需要依靠类似虚拟机这种中间层的支持的，这就能够在不损失性能的前提下，带来强大的跨平台可移植能力。

　　当然这种理解很美好，但实际上很多兼容POSIX标准的操作系统所做的实现是在自身原有的API接口的基础之上再封装创建一层POSIX兼容层来提供对POSIX支持，因此这意味着会占用更多一些的系统资源，但这种操作系统的原生支持（即便是二次封装出来的）相比较依托虚拟机的程序来说性能还是要给力的多的多。

　　POSIX解决什么问题：

　　一般情况下，应用程序通过应用编程接口(API)而不是直接通过系统调用来编程(即应用程序并不需要通过内核提供的系统调用来编程)。一个API（应用程序接口）定义了一组应用程序使用的编程接口。它们通过调用一个系统来实现，也可以通过调用多个系统来实现，而完全不使用任何系统调用也不存在问题。实际上，API可以在各种不同的操作系统上实现给应用程序提供完全相同的接口，而它们本身在这些系统上的实现却可能迥异。

　　如下图，当应用程序调用printf()函数时，printf函数会调用C库中的printf，继而调用C库中的write，C库最后调用内核的write()。

 

 

 

 

 

 

 

 

　　从程序员的角度看，系统调用无关紧要，只需要跟API打交道。相反，内核只跟系统调用打交道，库函数及应用程序是怎么系统调用不是内核所关心的。

　　完成同一功能，不同内核提供的系统调用（也就是一个函数）是不同的，例如创建进程，linux下是fork函数，windows下是creatprocess函数。好，我现在在linux下写一个程序，用到fork函数，那么这个程序该怎么往windows上移植？我需要把源代码里的fork通通改成creatprocess，然后重新编译...

　　主流的操作系统有两种，一种是Windows系统，另一种是Linux系统。由于操作系统的不同，API又分为Windows API和Linux API。在Windows平台开发出来的软件在Linux上无法运行，在Linux上开发的软件在Windows上又无法运行，这就导致了软件移植困难，POSIX(Protabl Operation System 可移植操作系统规范)应运而生。

　　posix标准的出现就是为了解决这个问题。linux和windows都要实现基本的posix标准，linux把fork函数封装成posix_fork（随便说的），windows把creatprocess函数也封装成posix_fork，都声明在unistd.h里。这样，程序员编写普通应用时候，只用包含unistd.h，调用posix_fork函数，程序就在源代码级别可移植了。

4、5种IO模型

　　 5种IO模型分别是阻塞IO模型、非阻塞IO模型、IO复用模型、信号驱动的IO模型、异步IO模型，前4种为同步IO操，只有异步IO模型是异步IO操作。

　　（1）阻塞IO模型

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

　　阻塞IO模型是最传统的一种IO模型，即在读写数据过程中会发生阻塞现象。大部分程序使用的都是阻塞模式的IO。

　　户进程调用了recvfrom这个系统，内核就开始了IO的第一个阶段：准备数据。对于网络IO来说，很多时候数据在一开始还没有到达（比如：还没有收到一个完整的UDP包），这个时候内核就要等待足够的数据到来，而在用户进程这边，整个进程会被阻塞。当内核等到数据准备好了，它就会将数据从内核中拷贝到用户内存，然后返回结果，用户进程才解除阻塞的状态，重新运行起来。几乎所有的程序员第一次接触到的网络编程都是从listen()、send()、recv()等接口开始的，这些接口都是阻塞型的。

　　简而言之也就是说，当用户进程发出IO请求之后，内核会去查看数据是否就绪，如果没有就绪就会等待数据就绪，而用户进程就会处于阻塞状态，用户进程交出CPU。当数据就绪之后，内核会将数据拷贝到用户进程，并返回结果给用户进程，用户进程才解除阻塞状态。　　

　　read()、recv()、recvfrom()、write()、send()、accept()、connet()等函数在调用过程中都会发生阻塞，以read函数为例：

　　进程调用read()函数从套接字上读取数据，当套接字的接收缓冲区中还没有数据可读，函数read()将发生阻塞。它会一直阻塞下去，等到套接字的接收缓冲区中有数据可读为止。当经过一段时间后，缓冲区接收到数据，于是内核便去唤醒该进程，通过read()访问这些数据。如果在进程阻塞过程中，对方发生故障，那这个进程将一直阻塞下去。　

　　在写操作时发生阻塞的情况要比读操作少。主要发生在要写入的缓冲区的大小小于要写入得数据量的情况下。这时，写操作不进行任何拷贝工作，将发生阻塞。一旦发送缓冲区内有足够的空间，内核将唤醒进程，将数据从用户缓冲区中拷贝到相应的发送数据缓冲区。　　

　　UDP不用等待确认，没有实际的发送缓冲区，所以UDP协议中不存在发送缓冲区满的情况，在UDP套接字上执行的写操作永远都不会阻塞。

　　阻塞IO的特点：

　　　　在IO执行的两个阶段（等待数据和拷贝数据两个阶段）都被阻塞了

　　　　进程阻塞挂起不消耗CPU资源、及时响应每个操作

　　　　实现难度低、开发应用较容易

　　　　适用并发量小的网络应用开发

　　　　不适用并发量大的应用，因为一个请求IO会阻塞进程，所以，得为每请求分配一个处理进程（线程）以及时响应，系统开销大

　　典型应用：阻塞Socket、Java BIO

（2）非阻塞IO

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

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

　　非阻塞的接口相比于阻塞型接口的显著差异在于：在被调用之后立即返回。

　　所以事实上，在非阻塞IO模型中，用户进程或线程需要不断地询问内核数据是否就绪，也就说非阻塞IO不会交出CPU，而会一直占用CPU，这是一个极其浪费CPU资源的操作，这种模式很少使用。

　　非阻塞IO的特点：

　　　　在非阻塞式IO中、用户进程其实是需要不断的主动询问kernel数据准备好了没有

　　　　进程轮询（重复）调用、消耗CPU的资源

　　　　实现难度低、开发应用相对阻塞IO模式较难

　　　　适用并发量较小、且不需要及时响应的网络应用开发

　　典型应用：Socket 设置 NONBLOCK

　　典型的非阻塞IO模型一般如下：

　　while(true)
　　{
　　　　data = socket.read();
　　　　if(data!= error)
　　　　{
　　　　　　//处理数据
　　　　　　break;
　　　　}
　　}

　　非阻塞模式的实现：int fcntl(int fd,int cmd,long arg);

　　在建立套接字描述符的时候，系统内核会将其设置为阻塞模式，可以通过fcntl()函数来设置套接字的标志为O_NONBLOCK，从而实现非阻塞。

　　　　　　int flag;

　　　　　　flag = fcntl(sockfd,F_GETFL,0);

　　　　　　flag = flag | O_NONBLOCK;

　　　　　　fcntl(sockfd,F_SETFL,flag);

　　但是对于非阻塞IO就有一个非常严重的问题，在while循环中需要不断地去询问内核数据是否就绪，这样会导致CPU占用率非常高，因此一般情况下很少使用while循环这种方式来读取数据。

（3）多路复用IO

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

　　多路复用IO模型是目前使用得比较多的模型。Java NIO实际上就是多路复用IO。

　　在应用程序中同时处理多路输入输出流时，若采用阻塞IO模式，将得不到预期的目的，因为阻塞IO模式同时只能处理一个输入输出流。若采用非阻塞IO模式，对多个输入输出流进行访问，会浪费CPU时间。若设置多个进程，分别处理一条数据通路，将产生进程间的同步与同信问题，使程序变得更加复杂。所以比较好的方法就是使用多路复用IO模型。

　　多路复用IO的基本思想是：

　　先构造一张有关文件描述符的表，然后调用select()函数，这些文件描述符中的一个或多个已准备好进行读写时函数才返回。当函数返回时告诉进程哪个文件描述符已就绪，可以进行IO操作。

　　使用select()函数可以完成非阻塞，当进程或线程执行到这些函数时不必非要等到事件的发生。

　　在多路复用IO模型中，会有一个进程或线程不断去轮询多个socket的状态，同时处理多个输入输出流。只有当socket真正有读写事件时，才真正调用实际的IO读写操作。因为在多路复用IO模型中，只需要使用一个进程或线程就可以管理多个socket，系统不需要建立新的进程或者线程，也不必维护这些进程或者线程，并且只有在真正有socket读写事件进行时，才会使用IO资源，所以它大大减少了资源占用。

　　多个进程的IO可以注册到一个复用器（select）上，当用户进程调用该select，select会监听所有注册进来的IO，如果select所有监听的IO在内核缓冲区都没有可读数据，select调用进程会被阻塞。而当任意一个IO在内核缓冲区中有可读数据时，select调用就会返回，之后select调用进程可以自己或通知另外的进程（注册进程）来再次发起读取IO，读取内核中准备好的数据，多个进程注册IO后，只有一个select调用进程被阻塞。

　　IO复用相对于阻塞和非阻塞更难理解，所以额外解释一段，其实多路复用IO模型和阻塞IO模型并没有太大的不同，事实上，还更差一些，因为这里需要使用两个系统调用（select和 recvfrom），而阻塞IO模型只有一次系统调用(recvfrom)。但是，用select的优势在于它可以同时处理多个连接，所以如果处理的连接个数不是很多的话，使用select/epoll的web server不一定比使用多线程加阻塞IO的web server性能更好，可能延迟还更大。

　　select/epoll的优势并不是对于单个连接能处理得更快，而是在于能处理更多的连接。

　　在IO复用模型中，对于每一个socket，一般都设置成为非阻塞。但是，如上图所示，整个用户的进程其实是一直被阻塞的，只不过进程是阻塞在select、poll、epoll等函数上，而没有阻塞在真正的I/O系统调用如recvfrom之上。

　　在Java NIO中，是通过selector.select()去查询每个通道是否有到达事件，如果没有事件，则一直阻塞在那里，因此这种方式会导致用户线程的阻塞。

　　也许有有人会说，我可以采用多进程/线程+ 阻塞IO 达到类似的效果，但是由于在多进程/线程 + 阻塞IO 中，每个socket对应一个进程或线程，这样会造成很大的资源占用，并且尤其是对于长连接来说，线程的资源一直不会释放，如果后面陆续有很多连接的话，就会造成性能上的瓶颈。

　　而多路复用IO模式，通过一个进程或线程就可以管理多个socket，只有当socket真正有读写事件发生才会占用资源来进行实际的读写操作。因此，多路复用IO比较适合连接数比较多的情况。

　　另外多路复用IO为何比非阻塞IO模型的效率高是因为在非阻塞IO中，不断地询问socket状态时通过用户进程或线程去进行的，而在多路复用IO中，轮询每个socket状态是内核在进行的，这个效率要比用户线程要高的多。

　　不过要注意的是，多路复用IO模型是通过轮询的方式来检测是否有事件到达，并且对到达的事件逐一进行响应。因此对于多路复用IO模型来说，一旦事件响应体很大，那么就会导致后续的事件迟迟得不到处理，并且会影响新的事件轮询。

　　多路复用IO的特点：

　　　　专一进程解决多个进程IO的阻塞问题、性能好、Reactor模式

　　　　实现、开发应用难度较大

　　　　适用高并发服务应用开发、一个进程/线程响应多个请求

　　典型应用：Java NIO、Nginx（epoll、poll、select）

（4）信号驱动IO模型

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

　　在信号驱动IO模型中，当用户线程发起一个IO请求操作，会给对应的socket注册一个信号函数，然后用户线程会继续执行，当内核数据就绪时会发送一个信号给用户线程，用户线程接收到信号之后，便在信号函数中调用IO读写操作来进行实际的IO请求操作。这个一般用于UDP中，对TCP套接口几乎是没用的，原因是该信号产生得过于频繁，并且该信号的出现并没有告诉我们发生了什么事情

 　　信号驱动式IO就是指进程预先告知内核，向内核注册一个信号处理函数，然后用户进程返回，不阻塞。当内核数据就绪时会发送一个信号给进程，用户进程便在信号处理函数中调用IO读取数据，从图中明白实际IO内核拷贝到用户进程的过程还是阻塞的，信号驱动式IO并没有实现真正的异步，因为通知到进程之后，依然是由进程来完成IO操作。

这和后面的异步IO模型很容易混淆，需要理解IO交互并结合五种IO模型的比较阅读。

　　信号驱动IO的特点：

　　　　在信号驱动式IO模型中，依然不符合POSIX描述的异步IO，只能算是半异步，并且实际中并不常用

　　　　回调机制、实现、开发应用难度大

（5）异步IO模型

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

　　异步IO模型才是最理想的IO模型，在异步IO模型中，当用户线程发起read操作之后，立刻就可以开始去做其它的事。而另一方面，从内核的角度，当它受到一个异步读取之后，它会立刻返回，说明read请求已经成功发起了，因此不会对用户线程产生任何阻塞。然后，内核会等待数据准备完成，然后将数据拷贝到用户线程，当这一切都完成之后，内核会给用户线程发送一个信号，告诉它read操作完成了。也就说用户线程完全不需要关心实际的整个IO操作是如何进行的，只需要先发起一个请求，当接收内核返回的成功信号时表示IO操作已经完成，可以直接去使用数据了。

　　用户进程发起aio_read（POSIX异步IO函数aio_或者lio_开头）操作之后，给内核传递描述符、缓冲区指针、缓冲区大小和read相同的三个参数以及文件偏移（与lseek类似），告诉内核当整个操作完成时，如何通知我们，立刻就可以开始去做其它的事。而另一方面，从内核的角度，当它受到一个aio_read之后，首先它会立刻返回，所以不会对用户进程产生任何阻塞，然后，内核会等待数据准备完成，然后将数据拷贝到用户内存。当这一切都完成之后，内核会给用户进程发送一个信号，告诉它aio_read操作完成了。

　　在异步IO模型中，IO操作的两个阶段都不会阻塞用户线程，这两个阶段都是由内核自动完成，然后发送一个信号告知用户线程操作已完成。用户线程中不需要再次调用IO函数进行具体的读写。这点是和信号驱动模型有所不同的，在信号驱动模型中，当用户线程接收到信号表示数据已经就绪，然后需要用户线程调用IO函数进行实际的读写操作；而在异步IO模型中，收到信号表示IO操作已经完成，不需要再在用户线程中调用iO函数进行实际的读写操作。

　　异步IO的工作机制是：告知内核启动某个操作，并让内核在整个操作完成后通知我们。这种模型与信号驱动的IO区别在于，信号驱动IO是由内核通知我们何时可以启动一个IO操作，这个IO操作由用户自定义的信号函数来实现，而异步IO模型是由内核告知我们IO操作何时完成。这和前面的信号驱动式IO模型很容易混淆，需要理解IO交互并结合五种IO模型的比较阅读。

　　注意，异步IO是需要操作系统的底层支持，在Java 7中，提供了Asynchronous IO。简称AIO

　　前面四种IO模型实际上都属于同步IO，只有异步IO模型才算是真正的异步IO，因为无论是多路复用IO还是信号驱动模型，IO操作的第2个阶段都会引起用户线程阻塞，也就是内核进行数据拷贝的过程都会让用户线程阻塞。

　　异步IO模型的特点：

　　　　不阻塞、数据一步到位、Proactor模式

　　　　需要操作系统的底层支持、LINUX 2.5 版本内核首现、2.6 版本产品的内核标准特性

　　　　回调机制、实现、开发应用难度大

　　　　非常适合高性能高并发应用

　　　　在异步IO模型中、真正实现了POSIX描述的异步IO、是五种IO模型中唯一的异步模型

　　典型应用：Java 7 AIO、高性能服务器应用

（6）五种IO模型的比较

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

　　阻塞IO和非阻塞IO的区别：
　　前面的介绍中其实已经很明确的说明了这两者的区别，调用阻塞会一直阻塞住对应的进程直到操作完成，而非阻塞IO在内核还没准备数据的情况下会立刻返回。阻塞和非阻塞关注的是进程在等待调用结果时的状态，阻塞是指调用结果返回之前，当前的进程会被挂起，调用进程只有在得到结果才会返回，非阻塞调用不能立刻得到结果，但该调用不会阻塞当前进程。

　　同步IO和异步IO区别：
　　两者的区别在于同步做IO操作的时候会将进程阻塞。按照这个定义，之前所述的阻塞IO、非阻塞IO、IO复用、信号驱动都属于同步IO。有人可能会说，非阻塞IO并没有被阻塞啊，这里有个非常狡猾的地方，定义中所指的IO操作是指真实的IO操作。就是例子中的recvfrom这个系统调用，非阻塞IO在执行recvfrom这个系统调用的时候，如果内核的数据没有准备好，这时候不会阻塞进程，但是，当内核中数据准备好的时候，recvfrom会将数据从内核拷贝到用户内存中，这个时候进程是被阻塞了。信号驱动也是同样的道理，在这段时间内，进程是被阻塞的。而异步IO则不一样，当进程发起IO操作之后，就直接返回再也不理睬了，直到内核发送一个信号，告诉进程说IO完成，在这整个过程中，进程完全没有被阻塞。

　　同步IO和异步IO的根本区别在于：同步IO主动的调用recvfrom来将数据拷贝到用户内存；异步则完全不同，它就像是用户进程将整个IO操作交给了他人（内核）完成，然后他人做完后发信号通知，在此期间，用户进程不需要去检查IO操作的状态，也不需要主动的去拷贝数据。

　　POSIX的定义: 同步I/O操作会阻塞请求进程，直到I/O操作完成；异步I/O操作不会导致请求进程被阻塞

　　信号驱动式IO和异步IO的区别：
　　这里之所以单独拿出来是因为如果还没有清除IO概念很容易混淆，所以理解IO模型之前一定要理解IO概念，如果看完前面两个问题，相信也能理解信号驱动IO与异步IO的区别在于启用异步IO意味着通知内核启动某个IO操作，并让内核在整个操作（包括数据从内核复制到用户缓冲区）完成时通知我们。也就是说，异步IO是由内核通知我们IO操作何时完成，即实际的IO操作也是异步的。信号驱动IO是由内核通知我们何时可以启动一个IO操作，这个IO操作由用户自定义的信号函数来实现。

 全篇最大的难点在于真正理解数据是如何从设备空间扭转到内核空间再到用户空间​

 5、两种高性能IO设计模式

　　在传统的网络服务设计模式中，有两种比较经典的模式：一种是多线程，一种是线程池。

　　多线程：

　　对于多线程模式，也就是说client一出现，服务器就会新建一个线程来处理该client的读写事件，如下图所示。

　　这种模式虽然处理起来简单方便，但是由于服务器为每个client的连接都采用一个线程去处理，使得资源占用非常大。因此，当连接数量达到上限时，再有用户请求连接，直接会导致资源瓶颈，严重的可能会直接导致服务器崩溃。因此，为了解决这种一个线程对应一个客户端模式带来的问题，提出了采用线程池的方式。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

　　线程池：

　　所谓线程池，就是说创建一个固定大小的线程池，来一个客户端，就从线程池取一个空闲线程来处理，当客户端处理完读写操作之后，就交出对线程的占用。因此这样就避免为每一个客户端都要创建线程带来的资源浪费，使得线程可以重用。

　　但是线程池也有它的弊端，如果连接大多是长连接，因此可能会导致在一段时间内，线程池中的线程都被占用，那么当再有用户请求连接时，由于没有可用的空闲线程来处理，就会导致客户端连接失败，从而影响用户体验。因此，线程池比较适合大量的短连接应用。

　　因此便出现了下面的两种高性能IO设计模式：Reactor和Proactor。

　　在Reactor模式中，会先对每个client注册感兴趣的事件，然后有一个线程专门去轮询每个client是否有事件发生，当有事件发生时，便顺序处理每个事件，当所有事件处理完之后，便再转去继续轮询，如下图所示。

　　从这里可以看出，上面的五种IO模型中的多路复用IO就是采用Reactor模式。注意，上面的图中展示的 是顺序处理每个事件，当然为了提高事件处理速度，可以通过多线程或者线程池的方式来处理事件。Java NIO使用的就是这种

　　在Proactor模式中，当检测到有事件发生时，会新起一个异步操作，然后交由内核线程去处理，当内核线程完成IO操作之后，发送一个通知告知操作已完成，可以得知，异步IO模型采用的就是Proactor模式。Java AIO使用的这种。