什么是 NIO？ NIO 和 BIO、AIO 之间的区别是什么？NIO主要用来解决什么问题？

秒速五厘米 2023-10-01 10:43 35阅读 0赞

## 1 BIO，NIO，AIO都有什么区别，NIO的原理是什么？ ##

#### BIO ####

BIO：传统的网络通讯模型，就是BIO，同步阻塞IO， 其实就是服务端创建一个ServerSocket， 然后就是客户端用一个Socket去连接服务端的那个ServerSocket， ServerSocket接收到了一个的连接请求就创建一个Socket和一个线程去跟那个Socket进行通讯。**接着客户端和服务端就进行阻塞式的通信**，客户端发送一个请求，服务端Socket进行处理后返回响应，在响应返回前，客户端那边就阻塞等待，什么事情也做不了。 这种方式的缺点， 每次一个客户端接入，都需要在服务端创建一个线程来服务这个客户端，这样大量客户端来的时候，就会造成服务端的线程数量可能达到了几千甚至几万，这样就可能会造成服务端过载过高，最后崩溃死掉。  
————————————————  
BIO模型图：

![img][]

Acceptor：

传统的IO模型的网络服务的设计模式中有俩种比较经典的设计模式： 一个是多线程， 一种是依靠线程池来进行处理。如果是基于多线程的模式来的话，就是这样的模式，这种也是

Acceptor线程模型。

![img][img 1]

#### NIO ####

NIO: NIO是一种同步非阻塞IO, 基于Reactor模型来实现的。其实相当于就是一个线程处理大量的客户端的请求，通过一个线程轮询大量的channel，每次就获取一批有事件的channel，然后对每个请求启动一个线程处理即可。这里的核心就是非阻塞，就那个selector一个线程就可以不停轮询channel，所有客户端请求都不会阻塞，直接就会进来，大不了就是等待一下排着队而已。这里面优化BIO的核心就是，一个客户端并不是时时刻刻都有数据进行交互，没有必要死耗着一个线程不放，所以客户端选择了让线程歇一歇，只有客户端有相应的操作的时候才发起通知，创建一个线程来处理请求。  
————————————————  
**NIO：模型图**

![img][img 2]

Reactor模型:

![img][img 3]

#### AIO ####

AIO：异步非阻塞IO，基于Proactor模型实现。 每个连接发送过来的请求，都会绑定一个Buffer，然后通知操作系统去完成异步的读，这个时间你就可以去做其他的事情，等到操作系统完成读之后，就会调用你的接口，给你操作系统异步读完的数据。这个时候你就可以拿到数据进行处理，将数据往回写，在往回写的过程，同样是给操作系统一个Buffer，让操作系统去完成写，写完了来通知你。这俩个过程都有buffer存在，数据都是通过buffer来完成读写。

这里面的主要的区别在于将数据写入的缓冲区后，就不去管它，剩下的去交给操作系统去完成。操作系统写回数据也是一样，写到Buffer里面，写完后通知客户端来进行读取数据。  
————————————————  
**AIO：模型图**

![img][img 4]

聊完了BIO，NIO，AIO的区别之后，现在我们再结合这三个模型来说下同步和阻塞的一些问题。

## 2 各种阻塞解释 ##

### 同步阻塞 ###

同步阻塞：为什么说BIO是同步阻塞的呢？其实这里说的不是针对网络通讯模型而言，而是针对磁盘文件读写IO操作来说的。因为用BIO的流读写文件，例如FileInputStrem，是说你发起个IO请求直接hang死，卡在那里，必须等着搞完了这次IO才能返回。

### 同步非阻塞: ###

同步非阻塞：为什么说NIO为啥是同步非阻塞？因为无论多少客户端都可以接入服务端，客户端接入并不会耗费一个线程，只会创建一个连接然后注册到selector上去罢了，你就可以去干其他你想干的其他事情了， 一个selector线程不断的轮询所有的socket连接，发现有事件了就通知你，然后你就启动一个线程处理一个请求即可，这个过程的话就是非阻塞的。但是这个处理的过程中，你还是要先读取数据，处理，再返回的，这是个同步的过程。

### 异步非阻塞 ###

异步非阻塞：为什么说AIO是异步非阻塞？通过AIO发起个文件IO操作之后，你立马就返回可以干别的事儿了，接下来你也不用管了，操作系统自己干完了IO之后，告诉你说ok了， 当你基于AIO的api去都写文件的时候， 当你发起一个请求之后，剩下的事情就是交给了操作系统，当读写完成后， 操作系统会来回调你的接口， 告诉你操作完成， 在这期间不需要等待， 也不需要去轮询判断操作系统完成的状态，你可以去干其他的事情。 同步就是自己还得主动去轮询操作系统，异步就是操作系统反过来通知你。所以来说， AIO就是异步非阻塞的。

## 3 NIO核心组件详细讲解 ##

学习NIO先来搞清楚一些相关的概念，NIO通讯有哪些相关组件，对应的作用都是什么，之间有哪些联系？

### 多路复用机制实现Selector ###

首先我们来了解下传统的Socket网络通讯模型。

**传统Socket通讯原理图**

![img][img 5]

#### 为什么传统的socket不支持海量连接 ####

每次一个客户端接入，都是要在服务端创建一个线程来服务这个客户端的，这会导致大量的客户端的时候，服务端的线程数量可能达到几千甚至几万，几十万，这会导致服务器端程序负载过高，不堪重负，最终系统崩溃死掉。

*  接着来看下NIO是如何基于Selector实现多路复用机制支持的海量连接。

**NIO原理图**

![img][img 6]

#### 多路复用机制是如何支持海量连接 ####

NIO的线程模型 对Socket发起的连接不需要每个都创建一个线程，完全可以使用一个Selector来多路复用监听N多个Channel是否有请求，该请求是对应的连接请求，还是发送数据的请求，这里面是基于操作系统底层的Select通知机制的，一个Selector不断的轮询多个Channel，这样避免了创建多个线程，只有当莫个Channel有对应的请求的时候才会创建线程，可能说1000个请求， 只有100个请求是有数据交互的， 这个时候可能server端就提供10个线程就能够处理这些请求。这样的话就可以避免了创建大量的线程。

#### NIO如何通过Buffer来缓冲数据的 ####

**NIO中的Buffer是个什么东西 ？**

![img][img 7]

学习NIO，首当其冲就是要了解所谓的Buffer缓冲区，这个东西是NIO里比较核心的一个部分，一般来说，如果你要通过NIO写数据到文件或者网络，或者是从文件和网络读取数据出来此时就需要通过Buffer缓冲区来进行。Buffer的使用一般有如下几个步骤：

**写入数据到Buffer，调用flip()方法，从Buffer中读取数据，调用clear()方法或者compact()方法。**

#### Buffer中对应的Position， Mark， Capacity，Limit都啥？ ####

![img][img 8]

capacity： 缓冲区容量的大小，就是里面包含的数据大小。  
limit： 对buffer缓冲区使用的一个限制，从这个index开始就不能读取数据了。  
position： 代表着数组中可以开始读写的index， 不能大于limit。  
mark： 是类似路标的东西，在某个position的时候，设置一下mark，此时就可以设置一个标记，后续调用reset()方法可以把position复位到当时设置的那个mark上去，把position或limit调整为小于mark的值时，就丢弃这个mark。如果使用的是Direct模式创建的Buffer的话，就会减少中间缓冲直接使用的是DirectorBuffer来进行数据的存储。  
————————————————

#### 如何通过Channel和FileChannel读取Buffer数据写入磁盘的 ####

NIO中，Channel是什么？

Channel是NIO中的数据通道，类似流，但是又有些不同，Channel即可从中读取数据，又可以从写数据到通道中，但是流的读写通常是单向的。Channel可以异步的读写。Channel中的数据总是要先读到一个Buffer中，或者从缓冲区中将数据写到通道中。

![img][img 9]

FileChannel的作用是什么 Buffer有不同的类型，同样Channel也有好几个类型。 FileChannel，DatagramChannel，SocketChannel，ServerSocketChannel。这些通道涵盖了UDP 和 TCP 网络IO，以及文件IO。而FileChannel就是文件IO对应的管道， 在读取文件的时候会用到这个管道。

## 4 问题（代码实现） ##

BIO 和 NIO 作为 Server 端，当建立了 10 个连接时，分别产生多少个线程？

答案： 因为传统的 IO 也就是 BIO 是同步线程堵塞的，所以每个连接都要分配一个专用线程来处理请求，这样 10 个连接就会创建 10 个线程去处理。而 NIO 是一种同步非阻塞的 I/O 模型，它的核心技术是多路复用，可以使用一个链接上的不同通道来处理不同的请求，所以即使有 10 个连接，对于 NIO 来说，开启 1 个线程就够了。  
————————————————

#### BIO 代码实现 ####

publicclassDemoServerextendsThread{
        
                privateServerSocket serverSocket;
                publicint getPort(){
        
                    return serverSocket.getLocalPort();
                }
                publicvoid run(){
        
                    try{
        
                        serverSocket =newServerSocket(0);
                        while(true){
        
                            Socket socket = serverSocket.accept();
                            RequestHandler requestHandler =newRequestHandler(socket);
                            requestHandler.start();
                        }
                    }catch(IOException e){
        
                        e.printStackTrace();
                    }finally{
        
                        if(serverSocket !=null){
        
                            try{
        
                                serverSocket.close();
                            }catch(IOException e){
        
                                e.printStackTrace();
                            }
                        }
                    }
                }
                publicstaticvoid main(String[] args)throwsIOException{
        
                    DemoServer server =newDemoServer();
                    server.start();
                    try(Socket client =newSocket(InetAddress.getLocalHost(), server.getPort())){
        
                        BufferedReader bufferedReader =newBufferedReader(newInputStreamReader(client.getInputStream()));
                        bufferedReader.lines().forEach(s ->System.out.println(s));
                    }
                }
            }
    // 简化实现，不做读取，直接发送字符串
            classRequestHandlerextendsThread{
        
                privateSocket socket;
                RequestHandler(Socket socket){
        
                    this.socket = socket;
                }
                @Override
                publicvoid run(){
        
                    try(PrintWriter out =newPrintWriter(socket.getOutputStream());){
        
                        out.println("Hello world!");
                        out.flush();
                    }catch(Exception e){
        
                        e.printStackTrace();
                    }
                }
            }

服务器端启动 ServerSocket，端口 0 表示自动绑定一个空闲端口。  
调用 accept 方法，阻塞等待客户端连接。  
利用 Socket 模拟了一个简单的客户端，只进行连接、读取、打印。  
当连接建立后，启动一个单独线程负责回复客户端请求。  
这样，一个简单的 Socket 服务器就被实现出来了。  
————————————————

![img][img 10]

#### NIO 代码实现 ####

publicclassNIOServerextendsThread{
        
                publicvoid run(){
        
                    try(Selector selector =Selector.open();
                        ServerSocketChannel serverSocket =ServerSocketChannel.open();){
        // 创建 Selector 和 Channel
                        serverSocket.bind(newInetSocketAddress(InetAddress.getLocalHost(),8888));
                        serverSocket.configureBlocking(false);
    // 注册到 Selector，并说明关注点
                        serverSocket.register(selector,SelectionKey.OP_ACCEPT);
                        while(true){
        
                            selector.select();// 阻塞等待就绪的 Channel，这是关键点之一
                            Set<SelectionKey> selectedKeys = selector.selectedKeys();
                            Iterator<SelectionKey> iter = selectedKeys.iterator();
                            while(iter.hasNext()){
        
                                SelectionKey key = iter.next();
    // 生产系统中一般会额外进行就绪状态检查
                                sayHelloWorld((ServerSocketChannel) key.channel());
                                iter.remove();
                            }
                        }
                    }catch(IOException e){
        
                        e.printStackTrace();
                    }
                }
                privatevoid sayHelloWorld(ServerSocketChannel server)throwsIOException{
        
                    try(SocketChannel client = server.accept();){
         client.write(Charset.defaultCharset().encode("Hello world!"));
                    }
                }
    // 省略了与前面类似的 main
            }

首先，通过 Selector.open() 创建一个 Selector，作为类似调度员的角色。  
然后，创建一个 ServerSocketChannel，并且向 Selector 注册，通过指定 SelectionKey.OP\_ACCEPT，告诉调度员，它关注的是新的连接请求。注意：为什么我们要明确配置非阻塞模式呢？这是因为阻塞模式下，注册操作是不允许的，会抛出 IllegalBlockingModeException 异常。  
Selector 阻塞在 select 操作，当有 Channel 发生接入请求，就会被唤醒。  
在 sayHelloWorld 方法中，通过 SocketChannel 和 Buffer 进行数据操作，在本例中是发送了一段字符串。  
可以看到，在前面两个样例中，IO 都是同步阻塞模式，所以需要多线程以实现多任务处理。而 NIO 则是利用了单线程轮询事件的机制，通过高效地定位就绪的 Channel，来决定做什么，仅仅 select 阶段是阻塞的，可以有效避免大量客户端连接时，频繁线程切换带来的问题，应用的扩展能力有了非常大的提高。

## 6 NIO与IO的区别 ##

NIO即New IO，这个库是在JDK1.4中才引入的。NIO和IO有相同的作用和目的，但实现方式不同，NIO主要用到的是块，所以NIO的效率要比IO高很多。在Java API中提供了两套NIO，一套是针对标准输入输出NIO，另一套就是网络编程NIO。  
NIO和IO的主要区别，下表总结了Java IO和NIO之间的主要区别：  
————————————————  
![img][img 11]

**1、面向流与面向缓冲**  
Java IO和NIO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。

**2、阻塞与非阻塞IO**  
Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write() 时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取，而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。

**3、选择器（Selectors）**  
Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

## 7 NIO和IO适用场景 ##

NIO是为弥补传统IO的不足而诞生的，但是尺有所短寸有所长，\*\*NIO也有缺点，因为NIO是面向缓冲区的操作，每一次的数据处理都是对缓冲区进行的，那么就会有一个问题，在数据处理之前必须要判断缓冲区的数据是否完整或者已经读取完毕，如果没有，假设数据只读取了一部分，那么对不完整的数据处理没有任何意义。\*\*所以每次数据处理之前都要检测缓冲区数据。  
那么NIO和IO各适用的场景是什么呢？  
如果需要管理同时打开的成千上万个连接，这些连接每次只是发送少量的数据，例如聊天服务器，这时候用NIO处理数据可能是个很好的选择。  
而如果只有少量的连接，而这些连接每次要发送大量的数据，这时候传统的IO更合适。使用哪种处理数据，需要在数据的响应等待时间和检查缓冲区数据的时间上作比较来权衡选择。

## 8 参考链接 ##

[https://blog.csdn.net/valada/article/details/96040288][https_blog.csdn.net_valada_article_details_96040288]

[https://blog.csdn.net/weixin\_44195108/article/details/88640803][https_blog.csdn.net_weixin_44195108_article_details_88640803]

[img]: https://img-blog.csdnimg.cn/2020020922573595.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 1]: https://img-blog.csdnimg.cn/20200209225822696.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 2]: https://img-blog.csdnimg.cn/20200209230411601.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 3]: https://img-blog.csdnimg.cn/20200209230432769.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 4]: https://img-blog.csdnimg.cn/20200209230709314.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 5]: https://img-blog.csdnimg.cn/2020020923115410.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 6]: https://img-blog.csdnimg.cn/20200209231240499.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 7]: https://img-blog.csdnimg.cn/20200209231354407.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 8]: https://img-blog.csdnimg.cn/2020020923150138.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 9]: https://img-blog.csdnimg.cn/20200209231547924.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 10]: https://img-blog.csdnimg.cn/20200209231838213.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[img 11]: https://img-blog.csdnimg.cn/20200209232226533.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MTU2MzE2MQ==,size_16,color_FFFFFF,t_70
[https_blog.csdn.net_valada_article_details_96040288]: https://blog.csdn.net/valada/article/details/96040288
[https_blog.csdn.net_weixin_44195108_article_details_88640803]: https://blog.csdn.net/weixin_44195108/article/details/88640803