10个最高频的Java NIO面试题剖析！

小咪咪 2021-12-07 14:41 184阅读 0赞

公众号后台回复“**学习**”，获取作者独家秘制精品资料

![640?wx\_fmt=png][640_wx_fmt_png]

多年好友心血力作，阿里资深技术专家十余年JVM生产实践经验

**《从零开始带你成为JVM实战高手》**

限时优惠：**88元**（**正在进行ing**）

**专栏目录**参见文末

扫下方海报进行**试读**

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg]

通过我的海报购买，**再返你24元**

**领取方式：**加微信号：Giotto1245**，暗号：**返现

![640?wx\_fmt=png][640_wx_fmt_png]

本文来自公众号读者胡宜宁的投稿

感谢胡宜宁同学的分享

###     ###

首先我们分别**画图来看看，****BIO、NIO、AIO，分别是什么？**

**BIO**：传统的网络通讯模型，就是BIO，同步阻塞IO

它其实就是服务端创建一个ServerSocket， 然后就是客户端用一个Socket去连接服务端的那个ServerSocket， ServerSocket接收到了一个的连接请求就创建一个Socket和一个线程去跟那个Socket进行通讯。

接着客户端和服务端就进行阻塞式的通信，客户端发送一个请求，服务端Socket进行处理后返回响应。

在响应返回前，客户端那边就阻塞等待，上门事情也做不了。

这种方式的缺点：每次一个客户端接入，都需要在服务端创建一个线程来服务这个客户端

这样大量客户端来的时候，就会造成服务端的线程数量可能达到了几千甚至几万，这样就可能会造成服务端过载过高，最后崩溃死掉。

######  ######

###### BIO模型图： ######

![640?wx\_fmt=png][640_wx_fmt_png 1]

###### **Acceptor：** ######

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

如果是基于多线程的模式来的话，就是这样的模式，这种也是Acceptor线程模型。

![640?wx\_fmt=png][640_wx_fmt_png 2]

#### NIO： ####

NIO是一种同步非阻塞IO, 基于Reactor模型来实现的。

其实相当于就是一个线程处理大量的客户端的请求，通过一个线程轮询大量的channel，每次就获取一批有事件的channel，然后对每个请求启动一个线程处理即可。

这里的核心就是非阻塞，就那个selector一个线程就可以不停轮询channel，所有客户端请求都不会阻塞，直接就会进来，大不了就是等待一下排着队而已。

这里面**优化BIO的核心**就是，一个客户端并不是时时刻刻都有数据进行交互，没有必要死耗着一个线程不放，所以客户端选择了让线程歇一歇，只有客户端有相应的操作的时候才发起通知，创建一个线程来处理请求。

######  ######

###### **NIO：模型图** ######

![640?wx\_fmt=png][640_wx_fmt_png 3]

**Reactor模型:**

![640?wx\_fmt=png][640_wx_fmt_png 4]

#### AIO ####

AIO：异步非阻塞IO，基于Proactor模型实现。

每个连接发送过来的请求，都会绑定一个Buffer，然后通知操作系统去完成异步的读，这个时间你就可以去做其他的事情

等到操作系统完成读之后，就会调用你的接口，给你操作系统异步读完的数据。这个时候你就可以拿到数据进行处理，将数据往回写

在往回写的过程，同样是给操作系统一个Buffer，让操作系统去完成写，写完了来通知你。

这俩个过程都有buffer存在，数据都是通过buffer来完成读写。

这里面的主要的区别在于将数据写入的缓冲区后，就不去管它，剩下的去交给操作系统去完成。

操作系统写回数据也是一样，写到Buffer里面，写完后通知客户端来进行读取数据。

**AIO：模型图**

![640?wx\_fmt=png][640_wx_fmt_png 5]

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

##### 同步阻塞 #####

为什么说BIO是同步阻塞的呢？

其实这里说的不是针对网络通讯模型而言，而是针对磁盘文件读写IO操作来说的。

因为用BIO的流读写文件，例如FileInputStrem，是说你发起个IO请求直接hang死，卡在那里，必须等着搞完了这次IO才能返回。

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

为什么说NIO为啥是同步非阻塞？

因为无论多少客户端都可以接入服务端，客户端接入并不会耗费一个线程，只会创建一个连接然后注册到selector上去，这样你就可以去干其他你想干的其他事情了

一个selector线程不断的轮询所有的socket连接，发现有事件了就通知你，然后你就启动一个线程处理一个请求即可，这个过程的话就是非阻塞的。

但是这个处理的过程中，你还是要先读取数据，处理，再返回的，这是个同步的过程。

#### 异步非阻塞 ####

为什么说AIO是异步非阻塞？

通过AIO发起个文件IO操作之后，你立马就返回可以干别的事儿了，接下来你也不用管了，操作系统自己干完了IO之后，告诉你说ok了

当你基于AIO的api去读写文件时， 当你发起一个请求之后，剩下的事情就是交给了操作系统

当读写完成后， 操作系统会来回调你的接口， 告诉你操作完成

在这期间不需要等待， 也不需要去轮询判断操作系统完成的状态，你可以去干其他的事情。

同步就是自己还得主动去轮询操作系统，异步就是操作系统反过来通知你。所以来说， AIO就是异步非阻塞的。

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

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

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

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

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

![640?wx\_fmt=png][640_wx_fmt_png 6]

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

每次一个客户端接入，都是要在服务端创建一个线程来服务这个客户端的

这会导致大量的客户端的时候，服务端的线程数量可能达到几千甚至几万，几十万，这会导致服务器端程序负载过高，不堪重负，最终系统崩溃死掉。

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

###### **NIO原理图** ######

![640?wx\_fmt=png][640_wx_fmt_png 7]

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

NIO的线程模型对Socket发起的连接不需要每个都创建一个线程，完全可以使用一个Selector来多路复用监听N多个Channel是否有请求，该请求是对应的连接请求，还是发送数据的请求

这里面是基于操作系统底层的Select通知机制的，一个Selector不断的轮询多个Channel，这样避免了创建多个线程

只有当莫个Channel有对应的请求的时候才会创建线程，可能说1000个请求， 只有100个请求是有数据交互的

这个时候可能server端就提供10个线程就能够处理这些请求。这样的话就可以避免了创建大量的线程。

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

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

![640?wx\_fmt=png][640_wx_fmt_png 8]

学习NIO，首当其冲就是要了解所谓的Buffer缓冲区，这个东西是NIO里比较核心的一个部分

一般来说，如果你要通过NIO写数据到文件或者网络，或者是从文件和网络读取数据出来此时就需要通过Buffer缓冲区来进行。Buffer的使用一般有如下几个步骤：

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

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

![640?wx\_fmt=png][640_wx_fmt_png 9]

*  **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中，或者从缓冲区中将数据写到通道中。

![640?wx\_fmt=png][640_wx_fmt_png 10]

FileChannel的作用是什么？

Buffer有不同的类型，同样Channel也有好几个类型。

*  FileChannel
 *  DatagramChannel
 *  SocketChannel
 *  ServerSocketChannel

这些通道涵盖了UDP 和 TCP 网络IO，以及文件IO。而FileChannel就是文件IO对应的管道， 在读取文件的时候会用到这个管道。

下面给一个简单的NIO实现读取文件的Demo代码

#### NIOServer端和Client端代码案例 ####

最后，给大家一个NIO客户端和服务端示例代码，简单感受下NIO通讯的方式。

*  NIO通讯Client端

import java.io.IOException;	
    import java.net.InetSocketAddress;	
    import java.nio.ByteBuffer;	
    import java.nio.channels.SelectionKey;	
    import java.nio.channels.Selector;	
    import java.nio.channels.SocketChannel;	
    import java.util.Iterator;	
    public class NIOClient {	
       public static void main(String[] args) {        	
           for(int i = 0; i < 10; i++){  	
               new Worker().start();  	
           }        	
       }  	
       static class Worker extends Thread {	
        @Override  	
        public void run() {       	
          SocketChannel channel = null;  	
          Selector selector = null;  	
          try {  	
              // SocketChannel，一看底层就是封装了一个Socket	
            channel = SocketChannel.open();         // SocketChannel是连接到底层的Socket网络	
            // 数据通道就是负责基于网络读写数据的	
            channel.configureBlocking(false);  	
            channel.connect(new InetSocketAddress("localhost", 9000)); 	
               // 后台一定是tcp三次握手建立网络连接	
            selector = Selector.open();  	
            //  监听Connect这个行为	
            channel.register(selector, SelectionKey.OP_CONNECT);          	
            while(true){  	
                // selector多路复用机制的实现  循环去遍历各个注册的Channel	
              selector.select();            	
              Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator();  	
              while(keysIterator.hasNext()){  	
                SelectionKey key = (SelectionKey) keysIterator.next();  	
                keysIterator.remove();  	
                // 如果发现返回的时候一个可连接的消息 走到下面去接受数据	
                if(key.isConnectable()){                channel = (SocketChannel) key.channel(); 	
                  if(channel.isConnectionPending()){  	
                    channel.finishConnect();	
                    // 接下来对这个SocketChannel感兴趣的就是人家server给你发送过来的数据了	
                    // READ事件，就是可以读数据的事件	
                    // 一旦建立连接成功了以后，此时就可以给server发送一个请求了	
                    ByteBuffer buffer = ByteBuffer.allocate(1024);	
                    buffer.put("你好".getBytes());	
                    buffer.flip();	
                    channel.write(buffer);  	
                  }   	
                  channel.register(selector, SelectionKey.OP_READ);	
                }  	
                // 这里的话就时候名服务器端返回了一条数据可以读了	
                else if(key.isReadable()){              channel = (SocketChannel) key.channel();	
                  // 构建一个缓冲区	
                  ByteBuffer buffer = ByteBuffer.allocate(1024); 	
                  // 把数据写入buffer，position推进到读取的字节数数字	
                  int len = channel.read(buffer);  	
                  if(len > 0) {	
                    System.out.println("[" + Thread.currentThread().getName() 	
                        + "]收到响应：" + new String(buffer.array(), 0, len)); 	
                    Thread.sleep(5000); 	
                    channel.register(selector, SelectionKey.OP_WRITE);	
                  }	
                } else if(key.isWritable()) {	
                        ByteBuffer buffer = ByteBuffer.allocate(1024);	
                        buffer.put("你好".getBytes());	
                        buffer.flip();	
                        channel = (SocketChannel) key.channel();	
                        channel.write(buffer);       	
                        channel.register(selector, SelectionKey.OP_READ);	
                      } 	
              }  	
            }                            	
          } catch (Exception e) {  	
            e.printStackTrace();  	
          } finally{  	
            if(channel != null){  	
              try {  	
                channel.close();  	
              } catch (IOException e) {                        	
                e.printStackTrace();  	
              }                    	
            }  	
            if(selector != null){  	
              try {  	
                selector.close();  	
              } catch (IOException e) {  	
                e.printStackTrace();  	
              }  	
            }  	
          }  	
        } 	
       }	
    }

*  NIO通讯Server端

**总结:**

通过本篇文章，主要是分析了常见的NIO的一些问题：

*  BIO， NIO， AIO各自的特点

*  什么同步阻塞，同步非阻塞，异步非阻塞
    
      
    
 *  为什么NIO能够应对支持海量的请求

*  NIO相关组件的原理

*  NIO通讯的简单案例

本文仅仅是介绍了一下网络通讯的一些原理，应对面试来讲解

NIO通讯其实有很多的的东西，在中间件的研发过程中使用的频率还是非常高的，后续有机会再和大家分享交流。

**END**

**如有收获，请划至底部，点击“在看”，谢谢！**

![640?wx\_fmt=png][640_wx_fmt_png]

**《从****零****开始带你成为JVM实战高手》**

专栏详细目录

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 1]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 2]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 3]

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 4]

![640?wx\_fmt=png][640_wx_fmt_png]

欢迎长按下图关注公众号**石杉的架构笔记**，后台回复“**学习**”

获取作者独家秘制精品资料

![640?wx\_fmt=jpeg][640_wx_fmt_jpeg 5]

**BAT架构经验倾囊相授**

[640_wx_fmt_png]: /images/20211207/d57c50afc1dc42d893fa99951b37ff14.png
[640_wx_fmt_jpeg]: /images/20211207/f7008d6558164203ab853a25fdd70b4d.png
[640_wx_fmt_png 1]: /images/20211207/82d5a5047dcc4b48aff8b466d556418c.png
[640_wx_fmt_png 2]: /images/20211207/2d96055199e042b9a4775fadab5d5c16.png
[640_wx_fmt_png 3]: /images/20211207/96b8258249634e45b42c292fb42276d7.png
[640_wx_fmt_png 4]: /images/20211207/ad5cf148ad4d4faf925c48e6a91121a6.png
[640_wx_fmt_png 5]: /images/20211207/35eea359a04542c4a0cb8fdf162aefac.png
[640_wx_fmt_png 6]: /images/20211207/3127628349e8467f9495965492e683ca.png
[640_wx_fmt_png 7]: /images/20211207/125828bf9eae40288f3a79bb378563ba.png
[640_wx_fmt_png 8]: /images/20211207/d589ec165f5e4d95b1deb74ad209694f.png
[640_wx_fmt_png 9]: /images/20211207/6b1006905b5d4fb08095e0348ca9accf.png
[640_wx_fmt_png 10]: /images/20211207/0dcfdd1fbc2c4da088e4712952dba574.png
[640_wx_fmt_jpeg 1]: /images/20211207/c86bc3dcb5484202bd38a7275c7e2ff9.png
[640_wx_fmt_jpeg 2]: /images/20211207/f8d674abb773404bb1a86a7d3dced1df.png
[640_wx_fmt_jpeg 3]: /images/20211207/ad6d56c16561446cb65ce06fa99af37c.png
[640_wx_fmt_jpeg 4]: /images/20211207/b920d4f68a3e4abb96cde31c31d39166.png
[640_wx_fmt_jpeg 5]: /images/20211207/f37d2a33baa84c7086bd04a4a317b41f.png