手记

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

石杉的架构笔记
2019-07-17 21:35:44浏览 4830

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

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

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

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

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

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

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

BIO模型图：

Acceptor：

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

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

NIO：

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

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

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

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

NIO：模型图

Reactor模型:

AIO

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

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

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

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

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

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

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

AIO：模型图

聊完了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通讯原理图

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

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

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

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

NIO原理图

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

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

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

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

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

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

NIO中的Buffer是个什么东西 ？

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

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

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

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

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

FileChannel的作用是什么？

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

  • FileChannel

  • DatagramChannel

  • SocketChannel

  • ServerSocketChannel

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

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

  1. public class FileChannelDemo1 {

  3.   public static void main(String[] args) throws Exception {
  4.     // 构造一个传统的文件输出流
  5.     FileOutputStream out = new FileOutputStream(
  6.         "F:\\development\\tmp\\hello.txt");
  7.     // 通过文件输出流获取到对应的FileChannel，以NIO的方式来写文件
  8.     FileChannel channel = out.getChannel();
  9.      // 将数据写入到Buffer中
  10.     ByteBuffer buffer = ByteBuffer.wrap("hello world".getBytes());
  11.     // 通过FileChannel管道将Buffer中的数据写到输出流中去，持久化到磁盘中去
  12.     channel.write(buffer);

  14.     channel.close();
  15.     out.close();
  16.   }
  17.   }
NIOServer端和Client端代码案例
最后，给大家一个NIO客户端和服务端示例代码，简单感受下NIO通讯的方式。
  • NIO通讯Client端
  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.SelectionKey;
  5. import java.nio.channels.Selector;
  6. import java.nio.channels.SocketChannel;
  7. import java.util.Iterator;

  9. public class NIOClient {

  11.    public static void main(String[] args) {        
  12.        for(int i = 0; i < 10; i++){  
  13.            new Worker().start();  
  14.        }        
  15.    }  

  17.    static class Worker extends Thread {

  19.     @Override  
  20.     public void run() {       
  21.       SocketChannel channel = null;  
  22.       Selector selector = null;  
  23.       try {  
  24.           // SocketChannel，一看底层就是封装了一个Socket
  25.         channel = SocketChannel.open();         // SocketChannel是连接到底层的Socket网络
  26.         // 数据通道就是负责基于网络读写数据的
  27.         channel.configureBlocking(false);  
  28.         channel.connect(new InetSocketAddress("localhost", 9000)); 
  29.            // 后台一定是tcp三次握手建立网络连接

  31.         selector = Selector.open();  
  32.         //  监听Connect这个行为
  33.         channel.register(selector, SelectionKey.OP_CONNECT);          
  34.         while(true){  
  35.             // selector多路复用机制的实现  循环去遍历各个注册的Channel
  36.           selector.select();            
  37.           Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator();  
  38.           while(keysIterator.hasNext()){  
  39.             SelectionKey key = (SelectionKey) keysIterator.next();  
  40.             keysIterator.remove();  
  41.             // 如果发现返回的时候一个可连接的消息 走到下面去接受数据
  42.             if(key.isConnectable()){                channel = (SocketChannel) key.channel(); 
  43.               if(channel.isConnectionPending()){  
  44.                 channel.finishConnect();
  45.                 // 接下来对这个SocketChannel感兴趣的就是人家server给你发送过来的数据了
  46.                 // READ事件，就是可以读数据的事件
  47.                 // 一旦建立连接成功了以后，此时就可以给server发送一个请求了
  48.                 ByteBuffer buffer = ByteBuffer.allocate(1024);
  49.                 buffer.put("你好".getBytes());
  50.                 buffer.flip();
  51.                 channel.write(buffer);  
  52.               }   

  54.               channel.register(selector, SelectionKey.OP_READ);
  55.             }  
  56.             // 这里的话就时候名服务器端返回了一条数据可以读了
  57.             else if(key.isReadable()){              channel = (SocketChannel) key.channel();

  59.               // 构建一个缓冲区
  60.               ByteBuffer buffer = ByteBuffer.allocate(1024); 
  61.               // 把数据写入buffer，position推进到读取的字节数数字
  62.               int len = channel.read(buffer);  
  63.               if(len > 0) {
  64.                 System.out.println("[" + Thread.currentThread().getName() 
  65.                     + "]收到响应：" + new String(buffer.array(), 0, len)); 
  66.                 Thread.sleep(5000); 
  67.                 channel.register(selector, SelectionKey.OP_WRITE);
  68.               }
  69.             } else if(key.isWritable()) {
  70.                     ByteBuffer buffer = ByteBuffer.allocate(1024);
  71.                     buffer.put("你好".getBytes());
  72.                     buffer.flip();

  74.                     channel = (SocketChannel) key.channel();
  75.                     channel.write(buffer);       
  76.                     channel.register(selector, SelectionKey.OP_READ);
  77.                   } 
  78.           }  
  79.         }                            
  80.       } catch (Exception e) {  
  81.         e.printStackTrace();  
  82.       } finally{  
  83.         if(channel != null){  
  84.           try {  
  85.             channel.close();  
  86.           } catch (IOException e) {                        
  87.             e.printStackTrace();  
  88.           }                    
  89.         }  

  91.         if(selector != null){  
  92.           try {  
  93.             selector.close();  
  94.           } catch (IOException e) {  
  95.             e.printStackTrace();  
  96.           }  
  97.         }  
  98.       }  
  99.     } 

  101.    }

  103. }
  • NIO通讯Server端
  1. import java.io.IOException;
  2. import java.net.InetSocketAddress;
  3. import java.nio.ByteBuffer;
  4. import java.nio.channels.ClosedChannelException;
  5. import java.nio.channels.SelectionKey;
  6. import java.nio.channels.Selector;
  7. import java.nio.channels.ServerSocketChannel;
  8. import java.nio.channels.SocketChannel;
  9. import java.util.Iterator;
  10. import java.util.concurrent.ExecutorService;
  11. import java.util.concurrent.Executors;
  12. import java.util.concurrent.LinkedBlockingQueue;

  14. public class NIOServer {

  16.     private static Selector selector;  
  17.     private static LinkedBlockingQueue<SelectionKey> requestQueue;
  18.     private static ExecutorService threadPool;

  20.     public static void main(String[] args) {
  21.       init();
  22.       listen();
  23.     }  

  25.     private static void init(){  
  26.         ServerSocketChannel serverSocketChannel = null;  

  28.         try {  
  29.           selector = Selector.open();

  31.           serverSocketChannel = ServerSocketChannel.open();  
  32.           // 将Channel设置为非阻塞的 NIO就是支持非阻塞的
  33.           serverSocketChannel.configureBlocking(false);         serverSocketChannel.socket().bind(new InetSocketAddress(9000), 100);    
  34.            // ServerSocket，就是负责去跟各个客户端连接连接请求的
  35.             serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);  
  36.             // 就是仅仅关注这个ServerSocketChannel接收到的TCP连接的请求
  37.         } catch (IOException e) {  
  38.             e.printStackTrace();  
  39.         }        

  41.         requestQueue = new LinkedBlockingQueue<SelectionKey>(500);

  43.         threadPool = Executors.newFixedThreadPool(10);
  44.         for(int i = 0; i < 10; i++) {
  45.           threadPool.submit(new Worker());  
  46.         }
  47.     }  

  49.   private static void listen() {  
  50.         while(true){  
  51.             try{  
  52.                 selector.select();               
  53.                 Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator();  

  55.                 while(keysIterator.hasNext()){  
  56.                     SelectionKey key = (SelectionKey) keysIterator.next();  
  57.                     // 可以认为一个SelectionKey是代表了一个请求
  58.                     keysIterator.remove();
  59.                     handleRequest(key);
  60.                 }  
  61.             }  
  62.             catch(Throwable t){  
  63.                 t.printStackTrace();  
  64.             }                            
  65.         }                
  66.     }  

  68.   private static void handleRequest(SelectionKey key)  
  69.             throws IOException, ClosedChannelException {  
  70.         // 后台的线程池中的线程处理下面的代码逻辑
  71.         SocketChannel channel = null;  

  73.         try{  
  74.             // 如果说这个Key是一个acceptable,也就是一个连接请求
  75.             if(key.isAcceptable()){  
  76.                 ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();  
  77.                 // 调用accept这个方法 就可以进行TCP三次握手了
  78.                 channel = serverSocketChannel.accept();                
  79.                 // 握手成功的话就可以获取到一个TCP连接好的SocketChannel
  80.                 channel.configureBlocking(false);  
  81.                 channel.register(selector, SelectionKey.OP_READ);  
  82.                 // 仅仅关注这个READ请求，就是人家发送数据过来的请求
  83.             }  
  84.             // 如果说这个key是readable，是个发送了数据过来的话，此时需要读取客户端发送过来的数据
  85.             else if(key.isReadable()){  
  86.                 channel = (SocketChannel) key.channel();  
  87.                 ByteBuffer buffer = ByteBuffer.allocate(1024);
  88.                 int count = channel.read(buffer); 
  89.                  // 通过底层的socket读取数据，写buffer中，position可能就会变成21之类的
  90.                 // 你读取到了多少个字节，此时buffer的position就会变成多少

  92.                 if(count > 0){   
  93.                  // 准备读取刚写入的数据，就是将limit设置为当前position，将position设置为0，丢弃mark。一般就是先写入数据，接着准备从0开始读这段数据，就可以用flip
  94.                   // position = 0，limit = 21，仅仅读取buffer中，0~21这段刚刚写入进去的数据
  95.                   buffer.flip();           
  96.                              System.out.println("服务端接收请求：" + new String(buffer.array(), 0, count));   
  97.                     channel.register(selector, SelectionKey.OP_WRITE);
  98.                 }                       
  99.             } else if(key.isWritable()) {
  100.               ByteBuffer buffer = ByteBuffer.allocate(1024);
  101.               buffer.put("收到".getBytes());
  102.               buffer.flip();

  104.               channel = (SocketChannel) key.channel();
  105.               channel.write(buffer);       
  106.               channel.register(selector, SelectionKey.OP_READ);
  107.             }
  108.         }  
  109.         catch(Throwable t){  
  110.             t.printStackTrace();  
  111.             if(channel != null){  
  112.                 channel.close();  
  113.             }  
  114.         }        
  115.     }

  117.   // 创建一个线程任务来执行
  118.   static class Worker implements Runnable {

  120.     @Override
  121.     public void run() {
  122.       while(true) {
  123.         try {
  124.           SelectionKey key = requestQueue.take();
  125.           handleRequest(key);
  126.         } catch (Exception e) {
  127.           e.printStackTrace();
  128.         }
  129.       }
  130.     }

  132.     private void handleRequest(SelectionKey key)  
  133.               throws IOException, ClosedChannelException {  
  134.         // 假设想象一下，后台有个线程池获取到了请求
  135.         // 下面的代码，都是在后台线程池的工作线程里在处理和执行
  136.           SocketChannel channel = null;  

  138.           try{  
  139.               // 如果说这个key是个acceptable，是个连接请求的话
  140.               if(key.isAcceptable()){                 System.out.println("[" + Thread.currentThread().getName() + "]接收到连接请求");        
  141.                   ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();  
  142.                   // 调用accept方法 和客户端进行三次握手
  143.                   channel = serverSocketChannel.accept();                   System.out.println("[" + Thread.currentThread().getName() + "]建立连接时获取到的channel=" + channel);     
  144.                   // 如果三次握手成功了之后，就可以获取到一个建立好TCP连接的SocketChannel
  145.                   // 这个SocketChannel大概可以理解为，底层有一个Socket，是跟客户端进行连接的
  146.                   // 你的SocketChannel就是联通到那个Socket上去，负责进行网络数据的读写的
  147.                   // 设置为非阻塞的
  148.                   channel.configureBlocking(false);  
  149.                   // 关注的是Reade请求
  150.                   channel.register(selector, SelectionKey.OP_READ);               } 

  152.                    // 如果说这个key是readable，是个发送了数据过来的话，此时需要读取客户端发送过来的数据
  153.               else if(key.isReadable()){  
  154.                   channel = (SocketChannel) key.channel();  
  155.                   ByteBuffer buffer = ByteBuffer.allocate(1024);
  156.                   int count = channel.read(buffer); 
  157.                    // 通过底层的socket读取数据，写入buffer中，position可能就会变成21之类的
  158.                   // 你读取到了多少个字节，此时buffer的position就会变成多少
  159.                   System.out.println("[" + Thread.currentThread().getName() + "]接收到请求");        

  161.                   if(count > 0){    
  162.                     buffer.flip();   // position = 0，limit = 21，仅仅读取buffer中，0~21这段刚刚写入进去的数据
  163.                       System.out.println("服务端接收请求：" + new String(buffer.array(), 0, count));   
  164.                       channel.register(selector, SelectionKey.OP_WRITE);
  165.                   }                       
  166.               } else if(key.isWritable()) {
  167.                 ByteBuffer buffer = ByteBuffer.allocate(1024);
  168.                 buffer.put("收到".getBytes());
  169.                 buffer.flip();

  171.                 channel = (SocketChannel) key.channel();
  172.                 channel.write(buffer);       
  173.                 channel.register(selector, SelectionKey.OP_READ);
  174.               }
  175.           }  
  176.           catch(Throwable t){  
  177.               t.printStackTrace();  
  178.               if(channel != null){  
  179.                   channel.close();  
  180.               }  
  181.           }        
  182.       }

  184.   }

  186. }
总结:
    通过本篇文章，主要是分析了常见的NIO的一些问题：
  • BIO， NIO， AIO各自的特点
  • 什么同步阻塞，同步非阻塞，异步非阻塞
  • 为什么NIO能够应对支持海量的请求
  • NIO相关组件的原理
  • NIO通讯的简单案例
本文仅仅是介绍了一下网络通讯的一些原理，应对面试来讲解
NIO通讯其实有很多的的东西，在中间件的研发过程中使用的频率还是非常高的，后续有机会再和大家分享交流。


END
石杉的架构笔记（id：shishan100）                       
作者：中华石杉，多年BAT架构经验倾囊相授 

	
	

	

		

			
相关标签

			
			
Java

			
		

	

	

		
		

		
		

		
			

		
			

		
			

		
			

		
			

		
			
5人推荐

		

	





	随时随地看视频
慕课网APP






	
热门评论

	

	
		

			
			

				
				
requestQueue = new LinkedBlockingQueue<SelectionKey>(500);
threadPool = Executors.newFixedThreadPool(10);
这段好像没有用到吧，要是线程池的应该如何使用呢


			

		

	
		

			
			

				
				
水平不够还是看不懂啊

			

		

	
	

	查看全部评论





	
	





	
相关阅读

	

	
		
操作系统第五篇【死锁】

	
		
力扣89——格雷编码

	
		
【Hadoop篇08】Hadoop数据压缩

	
		
记录一次数据库学习

	
		
CTO怒了：“如果中台不省钱，我建个屁中台啊！”