为了账号安全,请及时绑定邮箱和手机立即绑定

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

2019.07.17 21:35 1412浏览

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

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

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

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

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

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

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

BIO模型图:

https://img4.mukewang.com/5d2f2377000140d107770586.jpg

Acceptor:

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

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

https://img.mukewang.com/5d2f237d0001ac4107750564.jpg

NIO:

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

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

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

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

NIO:模型图

https://img.mukewang.com/5d2f238800013b7809650589.jpg

Reactor模型:

https://img3.mukewang.com/5d2f23940001690e05530451.jpg

AIO

AIO:异步非阻塞IO,基于Proactor模型实现。

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

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

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

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

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

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

AIO:模型图

https://img2.mukewang.com/5d2f239800014f9206570338.jpg

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

https://img3.mukewang.com/5d2f239d000198fd09680498.jpg

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

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

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

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

NIO原理图

https://img4.mukewang.com/5d2f23e60001d16606590324.jpg

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

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

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

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

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

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

NIO中的Buffer是个什么东西 ?

https://img4.mukewang.com/5d2f23e90001c04306420269.jpg

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

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

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

Buffer中对应的Position, Mark, Capacity,Limit都啥?

https://img3.mukewang.com/5d2f23f10001789906960231.jpg

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

https://img1.mukewang.com/5d2f23f80001536406770312.jpg

FileChannel的作用是什么?

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

  • FileChannel

  • DatagramChannel

  • SocketChannel

  • ServerSocketChannel

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

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

  1. public class FileChannelDemo1 {


  2.  public static void main(String[] args) throws Exception {

  3.    // 构造一个传统的文件输出流

  4.    FileOutputStream out = new FileOutputStream(

  5.        "F:\\development\\tmp\\hello.txt");

  6.    // 通过文件输出流获取到对应的FileChannel,以NIO的方式来写文件

  7.    FileChannel channel = out.getChannel();

  8.     // 将数据写入到Buffer中

  9.    ByteBuffer buffer = ByteBuffer.wrap("hello world".getBytes());

  10.    // 通过FileChannel管道将Buffer中的数据写到输出流中去,持久化到磁盘中去

  11.    channel.write(buffer);


  12.    channel.close();

  13.    out.close();

  14.  }

  15.  }

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;


  8. public class NIOClient {


  9.   public static void main(String[] args) {        

  10.       for(int i = 0; i < 10; i++){  

  11.           new Worker().start();  

  12.       }        

  13.   }  


  14.   static class Worker extends Thread {


  15.    @Override  

  16.    public void run() {      

  17.      SocketChannel channel = null;  

  18.      Selector selector = null;  

  19.      try {  

  20.          // SocketChannel,一看底层就是封装了一个Socket

  21.        channel = SocketChannel.open();         // SocketChannel是连接到底层的Socket网络

  22.        // 数据通道就是负责基于网络读写数据的

  23.        channel.configureBlocking(false);  

  24.        channel.connect(new InetSocketAddress("localhost", 9000));

  25.           // 后台一定是tcp三次握手建立网络连接


  26.        selector = Selector.open();  

  27.        //  监听Connect这个行为

  28.        channel.register(selector, SelectionKey.OP_CONNECT);          

  29.        while(true){  

  30.            // selector多路复用机制的实现  循环去遍历各个注册的Channel

  31.          selector.select();            

  32.          Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator();  

  33.          while(keysIterator.hasNext()){  

  34.            SelectionKey key = (SelectionKey) keysIterator.next();  

  35.            keysIterator.remove();  

  36.            // 如果发现返回的时候一个可连接的消息 走到下面去接受数据

  37.            if(key.isConnectable()){                channel = (SocketChannel) key.channel();

  38.              if(channel.isConnectionPending()){  

  39.                channel.finishConnect();

  40.                // 接下来对这个SocketChannel感兴趣的就是人家server给你发送过来的数据了

  41.                // READ事件,就是可以读数据的事件

  42.                // 一旦建立连接成功了以后,此时就可以给server发送一个请求了

  43.                ByteBuffer buffer = ByteBuffer.allocate(1024);

  44.                buffer.put("你好".getBytes());

  45.                buffer.flip();

  46.                channel.write(buffer);  

  47.              }  


  48.              channel.register(selector, SelectionKey.OP_READ);

  49.            }  

  50.            // 这里的话就时候名服务器端返回了一条数据可以读了

  51.            else if(key.isReadable()){              channel = (SocketChannel) key.channel();


  52.              // 构建一个缓冲区

  53.              ByteBuffer buffer = ByteBuffer.allocate(1024);

  54.              // 把数据写入buffer,position推进到读取的字节数数字

  55.              int len = channel.read(buffer);  

  56.              if(len > 0) {

  57.                System.out.println("[" + Thread.currentThread().getName()

  58.                    + "]收到响应:" + new String(buffer.array(), 0, len));

  59.                Thread.sleep(5000);

  60.                channel.register(selector, SelectionKey.OP_WRITE);

  61.              }

  62.            } else if(key.isWritable()) {

  63.                    ByteBuffer buffer = ByteBuffer.allocate(1024);

  64.                    buffer.put("你好".getBytes());

  65.                    buffer.flip();


  66.                    channel = (SocketChannel) key.channel();

  67.                    channel.write(buffer);      

  68.                    channel.register(selector, SelectionKey.OP_READ);

  69.                  }

  70.          }  

  71.        }                            

  72.      } catch (Exception e) {  

  73.        e.printStackTrace();  

  74.      } finally{  

  75.        if(channel != null){  

  76.          try {  

  77.            channel.close();  

  78.          } catch (IOException e) {                        

  79.            e.printStackTrace();  

  80.          }                    

  81.        }  


  82.        if(selector != null){  

  83.          try {  

  84.            selector.close();  

  85.          } catch (IOException e) {  

  86.            e.printStackTrace();  

  87.          }  

  88.        }  

  89.      }  

  90.    }


  91.   }


  92. }

  • 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;


  13. public class NIOServer {


  14.    private static Selector selector;  

  15.    private static LinkedBlockingQueue<SelectionKey> requestQueue;

  16.    private static ExecutorService threadPool;


  17.    public static void main(String[] args) {

  18.      init();

  19.      listen();

  20.    }  


  21.    private static void init(){  

  22.        ServerSocketChannel serverSocketChannel = null;  


  23.        try {  

  24.          selector = Selector.open();


  25.          serverSocketChannel = ServerSocketChannel.open();  

  26.          // 将Channel设置为非阻塞的 NIO就是支持非阻塞的

  27.          serverSocketChannel.configureBlocking(false);         serverSocketChannel.socket().bind(new InetSocketAddress(9000), 100);    

  28.           // ServerSocket,就是负责去跟各个客户端连接连接请求的

  29.            serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);  

  30.            // 就是仅仅关注这个ServerSocketChannel接收到的TCP连接的请求

  31.        } catch (IOException e) {  

  32.            e.printStackTrace();  

  33.        }        


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


  35.        threadPool = Executors.newFixedThreadPool(10);

  36.        for(int i = 0; i < 10; i++) {

  37.          threadPool.submit(new Worker());  

  38.        }

  39.    }  


  40.  private static void listen() {  

  41.        while(true){  

  42.            try{  

  43.                selector.select();              

  44.                Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator();  


  45.                while(keysIterator.hasNext()){  

  46.                    SelectionKey key = (SelectionKey) keysIterator.next();  

  47.                    // 可以认为一个SelectionKey是代表了一个请求

  48.                    keysIterator.remove();

  49.                    handleRequest(key);

  50.                }  

  51.            }  

  52.            catch(Throwable t){  

  53.                t.printStackTrace();  

  54.            }                            

  55.        }                

  56.    }  


  57.  private static void handleRequest(SelectionKey key)  

  58.            throws IOException, ClosedChannelException {  

  59.        // 后台的线程池中的线程处理下面的代码逻辑

  60.        SocketChannel channel = null;  


  61.        try{  

  62.            // 如果说这个Key是一个acceptable,也就是一个连接请求

  63.            if(key.isAcceptable()){  

  64.                ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();  

  65.                // 调用accept这个方法 就可以进行TCP三次握手了

  66.                channel = serverSocketChannel.accept();                

  67.                // 握手成功的话就可以获取到一个TCP连接好的SocketChannel

  68.                channel.configureBlocking(false);  

  69.                channel.register(selector, SelectionKey.OP_READ);  

  70.                // 仅仅关注这个READ请求,就是人家发送数据过来的请求

  71.            }  

  72.            // 如果说这个key是readable,是个发送了数据过来的话,此时需要读取客户端发送过来的数据

  73.            else if(key.isReadable()){  

  74.                channel = (SocketChannel) key.channel();  

  75.                ByteBuffer buffer = ByteBuffer.allocate(1024);

  76.                int count = channel.read(buffer);

  77.                 // 通过底层的socket读取数据,写buffer中,position可能就会变成21之类的

  78.                // 你读取到了多少个字节,此时buffer的position就会变成多少


  79.                if(count > 0){  

  80.                 // 准备读取刚写入的数据,就是将limit设置为当前position,将position设置为0,丢弃mark。一般就是先写入数据,接着准备从0开始读这段数据,就可以用flip

  81.                  // position = 0,limit = 21,仅仅读取buffer中,0~21这段刚刚写入进去的数据

  82.                  buffer.flip();          

  83.                             System.out.println("服务端接收请求:" + new String(buffer.array(), 0, count));  

  84.                    channel.register(selector, SelectionKey.OP_WRITE);

  85.                }                      

  86.            } else if(key.isWritable()) {

  87.              ByteBuffer buffer = ByteBuffer.allocate(1024);

  88.              buffer.put("收到".getBytes());

  89.              buffer.flip();


  90.              channel = (SocketChannel) key.channel();

  91.              channel.write(buffer);      

  92.              channel.register(selector, SelectionKey.OP_READ);

  93.            }

  94.        }  

  95.        catch(Throwable t){  

  96.            t.printStackTrace();  

  97.            if(channel != null){  

  98.                channel.close();  

  99.            }  

  100.        }        

  101.    }


  102.  // 创建一个线程任务来执行

  103.  static class Worker implements Runnable {


  104.    @Override

  105.    public void run() {

  106.      while(true) {

  107.        try {

  108.          SelectionKey key = requestQueue.take();

  109.          handleRequest(key);

  110.        } catch (Exception e) {

  111.          e.printStackTrace();

  112.        }

  113.      }

  114.    }


  115.    private void handleRequest(SelectionKey key)  

  116.              throws IOException, ClosedChannelException {  

  117.        // 假设想象一下,后台有个线程池获取到了请求

  118.        // 下面的代码,都是在后台线程池的工作线程里在处理和执行

  119.          SocketChannel channel = null;  


  120.          try{  

  121.              // 如果说这个key是个acceptable,是个连接请求的话

  122.              if(key.isAcceptable()){                 System.out.println("[" + Thread.currentThread().getName() + "]接收到连接请求");        

  123.                  ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel();  

  124.                  // 调用accept方法 和客户端进行三次握手

  125.                  channel = serverSocketChannel.accept();                   System.out.println("[" + Thread.currentThread().getName() + "]建立连接时获取到的channel=" + channel);    

  126.                  // 如果三次握手成功了之后,就可以获取到一个建立好TCP连接的SocketChannel

  127.                  // 这个SocketChannel大概可以理解为,底层有一个Socket,是跟客户端进行连接的

  128.                  // 你的SocketChannel就是联通到那个Socket上去,负责进行网络数据的读写的

  129.                  // 设置为非阻塞的

  130.                  channel.configureBlocking(false);  

  131.                  // 关注的是Reade请求

  132.                  channel.register(selector, SelectionKey.OP_READ);               }


  133.                   // 如果说这个key是readable,是个发送了数据过来的话,此时需要读取客户端发送过来的数据

  134.              else if(key.isReadable()){  

  135.                  channel = (SocketChannel) key.channel();  

  136.                  ByteBuffer buffer = ByteBuffer.allocate(1024);

  137.                  int count = channel.read(buffer);

  138.                   // 通过底层的socket读取数据,写入buffer中,position可能就会变成21之类的

  139.                  // 你读取到了多少个字节,此时buffer的position就会变成多少

  140.                  System.out.println("[" + Thread.currentThread().getName() + "]接收到请求");        


  141.                  if(count > 0){    

  142.                    buffer.flip();   // position = 0,limit = 21,仅仅读取buffer中,0~21这段刚刚写入进去的数据

  143.                      System.out.println("服务端接收请求:" + new String(buffer.array(), 0, count));  

  144.                      channel.register(selector, SelectionKey.OP_WRITE);

  145.                  }                      

  146.              } else if(key.isWritable()) {

  147.                ByteBuffer buffer = ByteBuffer.allocate(1024);

  148.                buffer.put("收到".getBytes());

  149.                buffer.flip();


  150.                channel = (SocketChannel) key.channel();

  151.                channel.write(buffer);      

  152.                channel.register(selector, SelectionKey.OP_READ);

  153.              }

  154.          }  

  155.          catch(Throwable t){  

  156.              t.printStackTrace();  

  157.              if(channel != null){  

  158.                  channel.close();  

  159.              }  

  160.          }        

  161.      }


  162.  }


  163. }

总结:

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

  • BIO, NIO, AIO各自的特点

  • 什么同步阻塞,同步非阻塞,异步非阻塞

  • 为什么NIO能够应对支持海量的请求

  • NIO相关组件的原理

  • NIO通讯的简单案例

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

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



END

石杉的架构笔记(id:shishan100)                       
作者:中华石杉,多年BAT架构经验倾囊相授 

点击查看更多内容

本文原创发布于慕课网 ,转载请注明出处,谢谢合作

5人点赞

若觉得本文不错,就分享一下吧!

评论

相关文章推荐

正在加载中
意见反馈 帮助中心 APP下载
官方微信

举报

0/150
提交
取消