很多时候对于不同的IO模型的概念和原理我们可能不是很清楚，有时候可能也会在不同的IO间迷糊，笔者也是有同样的问题。所以经过系统的学习以后将我们常见的五种IO模型在这里做一下总结，以供大家参考和学习。

1.基本概念

五种IO模型包括：阻塞IO、非阻塞IO、IO多路复用、信号驱动IO、异步IO。为了对后面的内容的一些西域不混淆，首先给大家介绍一下系统调用常用的几个函数和基本概念。

1.1 系统调用函数

以下几个系统函数参考了一些书籍和文章，如果有不正确的地方还请大家指出。

函数名称	函数作用
recvfrom	提供给用户用于接收网络IO的系统接口，从套接字上接收一个消息，可同时应用于面向连接和无连接的套接字如果此系统调用返回值<0，并且 errno为EWOULDBLOCK或EAGAIN（套接字已标记为非阻塞，而接收操作被阻塞或者接收超时）时，连接正常，阻塞接收数据（这很关键，前4种IO模型都设计此系统调用）
select	允许程序同时在多个底层文件描述符上，等待输入的到达或输出的完成。以数组形式存储文件描述符，64位机器默认2048个。当有数据准备好时，无法感知具体是哪个流OK了，所以需要一个一个的遍历，函数的时间复杂度为O(n)
poll	以链表形式存储文件描述符，没有长度限制。本质与select相同，函数的时间复杂度也为O(n)
epoll	基于事件驱动。如果某个流准备好了，会以事件通知，知道具体是哪个流，因此不需要遍历，函数的时间复杂度为O(1)
sigaction	用于设置对信号的处理方式，也可检验对某信号的预设处理方式。Linux使用SIGIO信号来实现IO异步通知机制

1.2同步与异步

同步和异步是针对应用程序和内核交互而言的。

	概念
同步	用户进程触发IO操作并等待或轮询的去查看是否就绪
异步	用户进程触发IO操作以后便开始做自己的事情，当IO操作已经完成的时候会得到IO完成的通知，需要CPU支持

1.3阻塞与非阻塞

阻塞和非阻塞是针对于进程在访问数据的时候。根据IO操作的就绪状态来采取的不同的方式。

	概念
阻塞	阻塞方式下读取或写入方法将一直等待
非阻塞	非阻塞方式下读取或写入方法会立即返回一个状态值

2.IO模型介绍

2.1 阻塞IO模型

学习过操作系统的伙伴应该知道，不管是网络IO还是磁盘IO，对于读操作而言，都是等到网络的某个数据分组到达后/数据准备好后，将数据拷贝到内核空间的缓冲区中，再从内核空间拷贝到用户空间的缓冲区。执行流程图大致如图：

通过流程图可以看到，阻塞IO的执行过程是进程进行系统调用，等待内核将数据准备好并复制到用户态缓冲区后，进程放弃使用CPU并一直阻塞在此，直到数据准备好。

2.2 非阻塞IO模型

每次应用程序询问内核是否有数据准备好。如果就绪，就进行拷贝操作；如果未就绪，就不阻塞程序，内核直接返回未就绪的返回值，等待用户程序下一个轮询。在每一次询问之前，对于程序来说是非阻塞的，占用CPU资源，可以做其他事情。执行流程图大致如图：

主要有两个阶段：

等待数据阶段：未阻塞，用户进程需要盲等，不停的去轮询内核；
数据复制阶段：阻塞，此时进行数据复制。

在这两个阶段中，用户进程只有在数据复制阶段被阻塞了，而等待数据阶段没有阻塞，但是用户进程需要盲等，不停地轮询内核，看数据是否准备好。

2.3 IO多路复用模型

相比于阻塞IO模型，多路复用只是多了一个select/poll/epoll函数。select函数会不断地轮询自己所负责的文件描述符/套接字的到达状态，当某个套接字就绪时，就对这个套接字进行处理。select负责轮询等待，recvfrom负责拷贝。当用户进程调用该select，select会监听所有注册好的IO，如果所有IO都没注册好，调用进程就阻塞。多路复用一般都是用于网络IO，服务端与多个客户端的建立连接。执行流程图大致如图：

对于客户端来说，一般感受不到阻塞，因为请求来了，可以用放到线程池里执行；但对于执行select的操作系统而言，是阻塞的，需要阻塞地等待某个套接字变为可读。IO多路复用其实是阻塞在select，poll，epoll这类系统调用上的，复用的是执行select，poll，epoll的线程。

2.4 信号驱动IO模型

当数据报准备好的时候，内核会向应用程序发送一个信号，进程对信号进行捕捉，并且调用信号处理函数来获取数据报。执行流程图大致如图：

该模型也分为两个阶段：

数据准备阶段：未阻塞，当数据准备完成之后，会主动的通知用户进程数据已经准备完成，对用户进程做一个回调；
数据拷贝阶段：阻塞用户进程，等待数据拷贝。

2.5 异步IO模型

用户进程发起系统调用后，立刻就可以开始去做其他的事情，然后直到I/O数据准备好并复制完成后，内核会给用户进程发送通知，告诉用户进程操作已经完成了。

异步I/O执行的两个阶段都不会阻塞读写操作，由内核完成，完成后内核将数据放到指定的缓冲区，通知应用程序来取。

3.BIO，NIO，AIO介绍

操作系统的IO模型是底层基石，Java对于IO的操作其实就是进一步的封装。

3.1 BIO

BIO–同步阻塞，JDK1.4之前常用的编程方式，适用于连接数目比较小且固定的架构，对服务器资源要求高，并发局限于应用中。在使用的时候，首先在服务端启动一个ServerSocket来监听网络请求，客户端启动Socket发起网络请求，默认情况下ServerSocket会建立一个线程来处理此请求，如果服务端没有线程可用，客户端则会阻塞等待或遭到拒绝，并发效率比较低。
我们使用java来模拟IO模型的连接，首先编写服务端的代码：

/*** @Author likangmin* @create 2020/12/02 13:35*/
public class Server {public static void main(String[] args) {int port=genPort(args);ServerSocket server=null;ExecutorService service= Executors.newFixedThreadPool(50);try {server=new ServerSocket(port);System.out.println("server started!");while (true){Socket socket=server.accept();service.execute(new Handler(socket));}} catch (IOException e) {e.printStackTrace();}finally {if(server!=null){try {server.close();} catch (IOException e) {e.printStackTrace();}}server=null;}}private static int genPort(String[] args) {if(args.length>0){return Integer.parseInt(args[0]);}else{return 9999;}}static class Handler implements Runnable{Socket socket=null;public  Handler(Socket socket){this.socket=socket;}@Overridepublic void run() {BufferedReader reader=null;PrintWriter writer=null;try {reader=new BufferedReader(new InputStreamReader(socket.getInputStream(),"UTF-8"));writer=new PrintWriter(new OutputStreamWriter(socket.getOutputStream(),"UTF-8"));String readMassage=null;while (true){System.out.println("server reading...");if((readMassage=reader.readLine())==null){break;}System.out.println(readMassage);writer.println("server recive:"+readMassage);writer.flush();}} catch (IOException e) {e.printStackTrace();}finally {if(socket!=null){try {socket.close();} catch (IOException e) {e.printStackTrace();}}socket=null;if(reader!=null){try {reader.close();} catch (IOException e) {e.printStackTrace();}}reader=null;if(writer!=null){writer.close();}writer=null;}}}
}

编写一个客户端：

/*** @Author likangmin* @create 2020/12/02 13:35*/
public class Client {public static void main(String[] args) {String host=null;int port=0;if(args.length>2){host=args[0];port=Integer.parseInt(args[1]);}else{host="127.0.0.1";port=9999;}Socket socket=null;BufferedReader reader = null;PrintWriter writer = null;Scanner s = new Scanner(System.in);try{socket = new Socket(host, port);String message = null;reader = new BufferedReader(new InputStreamReader(socket.getInputStream(), "UTF-8"));writer = new PrintWriter(socket.getOutputStream(), true);while(true){message = s.nextLine();if(message.equals("exit")){break;}writer.println(message);writer.flush();System.out.println(reader.readLine());}}catch(Exception e){e.printStackTrace();}finally{if(socket != null){try {socket.close();} catch (IOException e) {e.printStackTrace();}}socket = null;if(reader != null){try {reader.close();} catch (IOException e) {e.printStackTrace();}}reader = null;if(writer != null){writer.close();}writer = null;}}
}

然后启动，先启动服务端，再启动客户端，然后输入数据

会发现服务端一直会阻塞在接收数据那里。

3.2 NIO

NIO–同步非阻塞，是基于事件驱动思想来完成的，适用于连接数目多且连接比较短（轻操作）的架构，比如聊天服务器，并发局限于应用中，编程复杂，JDK1.4 开始支持。当 socket 有流可读或可写入时，操作系统会相应地通知应用程序进行处理，应用再将流读取到缓冲区或写入操作系统。一个有效的请求对应一个线程，当连接没有数据时，是没有工作线程来处理的。
服务器实现模式为一个请求一个通道，即客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有 I/O 请求时才启动一个线程进行处理。NIO中有几个比较重要的角色：缓冲区Buffer，通道Channel，多路复用器Selector。
（1）Buffer
在NIO库中，所有数据都是用缓冲区（用户空间缓冲区）处理的。在读取数据时，它是直接读到缓冲区中的；在写入数据时，也是写入到缓冲区中。任何时候访问NIO中的数据，都是通过缓冲区进行操作。
缓冲区实际上是一个数组，并提供了对数据的结构化访问以及维护读写位置等信息。
（2）Channel
nio中对数据的读取和写入要通过Channel，它就像水管一样，是一个通道。通道不同于流的地方就是通道是双向的，可以用于读、写和同时读写操作。
（3）Selector
多路复用器，用于注册通道。客户端发送的连接请求都会注册到多路复用器上，多路复用器轮询到连接有I/O请求时才启动一个线程进行处理。
这里我们同样写一个demo作为例子，来让大家知道怎么使用和使用NIO的步骤，为了让大家看的比较清楚，在适当的地方添加了注释。同样的先写服务端的代码：

/*** @Author likangmin* @create 2020/12/02 13:35*/
public class NIOServer implements Runnable {// 多路复用器， 选择器。 用于注册通道的。private Selector selector;// 定义了两个缓存。分别用于读和写。 初始化空间大小单位为字节。private ByteBuffer readBuffer = ByteBuffer.allocate(1024);private ByteBuffer writeBuffer = ByteBuffer.allocate(1024);public static void main(String[] args) {new Thread(new NIOServer(9999)).start();}public NIOServer(int port) {init(port);}private void init(int port){try {System.out.println("server starting at port " + port + " ...");// 开启多路复用器this.selector = Selector.open();// 开启服务通道ServerSocketChannel serverChannel = ServerSocketChannel.open();// 非阻塞， 如果传递参数true，为阻塞模式。serverChannel.configureBlocking(false);// 绑定端口serverChannel.bind(new InetSocketAddress(port));// 注册，并标记当前服务通道状态/** register(Selector, int)* int - 状态编码*  OP_ACCEPT ： 连接成功的标记位。*  OP_READ ： 可以读取数据的标记*  OP_WRITE ： 可以写入数据的标记*  OP_CONNECT ： 连接建立后的标记*/serverChannel.register(this.selector, SelectionKey.OP_ACCEPT);System.out.println("server started.");} catch (IOException e) {e.printStackTrace();}}@Overridepublic void run(){while(true){try {// 阻塞方法，当至少一个通道被选中，此方法返回。// 通道是否选择，由注册到多路复用器中的通道标记决定。this.selector.select();// 返回以选中的通道标记集合， 集合中保存的是通道的标记。相当于是通道的ID。Iterator<SelectionKey> keys = this.selector.selectedKeys().iterator();while(keys.hasNext()){SelectionKey key = keys.next();// 将本次要处理的通道从集合中删除，下次循环根据新的通道列表再次执行必要的业务逻辑keys.remove();// 通道是否有效if(key.isValid()){// 阻塞状态try{if(key.isAcceptable()){accept(key);}}catch(CancelledKeyException cke){// 断开连接。 出现异常。key.cancel();}// 可读状态try{if(key.isReadable()){read(key);}}catch(CancelledKeyException cke){key.cancel();}// 可写状态try{if(key.isWritable()){write(key);}}catch(CancelledKeyException cke){key.cancel();}}}} catch (IOException e) {e.printStackTrace();}}}private void write(SelectionKey key){this.writeBuffer.clear();SocketChannel channel = (SocketChannel)key.channel();Scanner reader = new Scanner(System.in);try {System.out.print("put message for send to client > ");String line = reader.nextLine();// 将控制台输入的字符串写入Buffer中。 写入的数据是一个字节数组。writeBuffer.put(line.getBytes("UTF-8"));writeBuffer.flip();channel.write(writeBuffer);channel.register(this.selector, SelectionKey.OP_READ);} catch (IOException e) {e.printStackTrace();}}private void read(SelectionKey key){try {// 清空读缓存。this.readBuffer.clear();// 获取通道SocketChannel channel = (SocketChannel)key.channel();// 将通道中的数据读取到缓存中。通道中的数据，就是客户端发送给服务器的数据。int readLength = channel.read(readBuffer);// 检查客户端是否写入数据。if(readLength == -1){// 关闭通道key.channel().close();// 关闭连接key.cancel();return;}/** flip， NIO中最复杂的操作就是Buffer的控制。* Buffer中有一个游标。游标信息在操作后不会归零，如果直接访问Buffer的话，数据有不一致的可能。* flip是重置游标的方法。NIO编程中，flip方法是常用方法。*/this.readBuffer.flip();// 字节数组，保存具体数据的。 Buffer.remaining() -> 是获取Buffer中有效数据长度的方法。byte[] datas = new byte[readBuffer.remaining()];// 是将Buffer中的有效数据保存到字节数组中。readBuffer.get(datas);System.out.println("from " + channel.getRemoteAddress() + " client : " + new String(datas, "UTF-8"));// 注册通道， 标记为写操作。channel.register(this.selector, SelectionKey.OP_WRITE);} catch (IOException e) {e.printStackTrace();try {key.channel().close();key.cancel();} catch (IOException e1) {e1.printStackTrace();}}}private void accept(SelectionKey key){try {// 此通道为init方法中注册到Selector上的ServerSocketChannelServerSocketChannel serverChannel = (ServerSocketChannel)key.channel();// 阻塞方法，当客户端发起请求后返回。 此通道和客户端一一对应。SocketChannel channel = serverChannel.accept();channel.configureBlocking(false);// 设置对应客户端的通道标记状态，此通道为读取数据使用的。channel.register(this.selector, SelectionKey.OP_READ);} catch (IOException e) {e.printStackTrace();}}
}

然后再写客户端的代码：

/*** @Author likangmin* @create 2020/12/02 13:35*/
public class NIOClient {public static void main(String[] args) {// 远程地址创建InetSocketAddress remote = new InetSocketAddress("localhost", 9999);SocketChannel channel = null;// 定义缓存。ByteBuffer buffer = ByteBuffer.allocate(1024);try {// 开启通道channel = SocketChannel.open();// 连接远程服务器。channel.connect(remote);Scanner reader = new Scanner(System.in);while(true){System.out.print("put message for send to server > ");String line = reader.nextLine();if(line.equals("exit")){break;}// 将控制台输入的数据写入到缓存。buffer.put(line.getBytes("UTF-8"));// 重置缓存游标buffer.flip();// 将数据发送给服务器channel.write(buffer);// 清空缓存数据。buffer.clear();// 读取服务器返回的数据int readLength = channel.read(buffer);if(readLength == -1){break;}// 重置缓存游标buffer.flip();byte[] datas = new byte[buffer.remaining()];// 读取数据到字节数组。buffer.get(datas);System.out.println("from server : " + new String(datas, "UTF-8"));// 清空缓存。buffer.clear();}} catch (IOException e) {e.printStackTrace();} finally{if(null != channel){try {channel.close();} catch (IOException e) {e.printStackTrace();}}}}
}

然后我们先启动服务端，然后再启动客户端

3.3 AIO

AIO–异步非阻塞，进行读写操作时，只须直接调用api的read或write方法即可。一个有效请求对应一个线程，客户端的IO请求都是OS先完成了再通知服务器应用去启动线程进行处理。这里就不做代码演示了，大家又需要可以自己去找一些代码查看，操作起来比较简单。

4.总结

最后给大家做一下总结，从效率上来说，可以简单理解为阻塞IO<非阻塞IO<多路复用IO<信号驱动IO<异步IO。从同步和异步来说，只有异步IO模型是异步的，其他均为同步。

常用 IO 模型图解介绍相关推荐

Netty之四种常用 IO 模型
四种常用 IO 模型: 同步阻塞 BIO: 最简单的 IO 模型,用户线程在读写时被阻塞. 数据拷贝指请求到的数据先存放在内核空间, 然后从内核空间拷贝至程序的缓冲区. 用户线程在 IO 过程中被阻塞 ...
网络IO模型的介绍引出nginx的网络IO模型
1. 什么是IO? 简单来说就是输入输出 2. 网络IO经历步骤用户在获取网络资源是在进入网卡,经过网络七层模型将请求交给nginx用户进程用户进程无法直接获取磁盘上的资源,会将请求获取什么资源翻 ...
mysql io模型_5种网络IO模型
同步(synchronous) IO和异步(asynchronous) IO,阻塞(blocking) IO和非阻塞(non-blocking)IO分别是什么,到底有什么区别?这个问题其实不同的人给出 ...
5种网络IO模型：阻塞IO、非阻塞IO、异步IO、多路复用IO、信号驱动IO
目录前言阻塞IO(blocking IO) 非阻塞IO(non-blocking IO) 多路复用IO(IO multiplexing) 异步IO(Asynchronous I/O) 模型间的区别 ...
python 网络编程异步io_python网络编程——网络IO模型
服务器端编程经常需要构造高性能的IO模型,常见的IO模型有四种: (1)同步阻塞IO(Blocking IO):即传统的IO模型. (2)同步非阻塞IO(Non-blocking IO):默认创建的s ...
1.聊聊Netty那些事儿之从内核角度看IO模型
从今天开始我们来聊聊Netty的那些事儿,我们都知道Netty是一个高性能异步事件驱动的网络框架. 它的设计异常优雅简洁,扩展性高,稳定性强.拥有非常详细完整的用户文档. 同时内置了很多非常有用的模块 ...
聊聊Netty那些事儿之从内核角度看IO模型
从今天开始我们来聊聊Netty的那些事儿,我们都知道Netty是一个高性能异步事件驱动的网络框架. 它的设计异常优雅简洁,扩展性高,稳定性强.拥有非常详细完整的用户文档. 同时内置了很多非常有用的模块 ...
Linux io模型及函数调用,Linux 网络编程的5种IO模型：信号驱动IO模型
Linux 网络编程的5种IO模型:信号驱动IO模型背景这一讲我们来看信号驱动IO 模型. 介绍情景引入: 在信号驱动IO模型中,当用户线程发起一个IO请求操作,会给对应的socket注册一个 ...
深入浅出Unix IO模型
前言在介绍Unix IO模型之前,我们先来说说什么是IO.根据维基百科的定义,IO 指的是输入输出,通常指数据在内部存储器和外部存储器或其他周边设备之间的输入和输出.简而言之,从硬盘中读写数据或者从 ...

常用 IO 模型图解介绍