最新公告
  • 新注册用户请前往个人中心绑定邮箱以便接收相关凭证邮件！！！点击前往个人中心
    • 5年
    程序员的加油站
    热门推荐
    赞助用户
    极客文库

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

    2019-07-16 多啦H梦 1.34K 已收录
    当前位置：极客文库 > 技术杂谈 > 10个最高频的Java NIO面试题剖析！
    正文概述 评论

     

    首先我们分别画图来看看，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. publicclassFileChannelDemo1{
    3. publicstaticvoid main(String[] args)throwsException{
    4. // 构造一个传统的文件输出流
    5. FileOutputStreamout=newFileOutputStream(
    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. publicclassNIOClient{
    11. publicstaticvoid main(String[] args){
    12. for(int i =0; i <10; i++){
    13. newWorker().start();
    14. }
    15. }
    17. staticclassWorkerextendsThread{
    19. @Override
    20. publicvoid 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(newInetSocketAddress("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. elseif(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. +"]收到响应："+newString(buffer.array(),0, len));
    66. Thread.sleep(5000);
    67. channel.register(selector,SelectionKey.OP_WRITE);
    68. }
    69. }elseif(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. publicclassNIOServer{
    16. privatestaticSelector selector;
    17. privatestaticLinkedBlockingQueue<SelectionKey> requestQueue;
    18. privatestaticExecutorService threadPool;
    20. publicstaticvoid main(String[] args){
    21. init();
    22. listen();
    23. }
    25. privatestaticvoid 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(newInetSocketAddress(9000),100);
    34. // ServerSocket，就是负责去跟各个客户端连接连接请求的
    35. serverSocketChannel.register(selector,SelectionKey.OP_ACCEPT);
    36. // 就是仅仅关注这个ServerSocketChannel接收到的TCP连接的请求
    37. }catch(IOException e){
    38. e.printStackTrace();
    39. }
    41. requestQueue =newLinkedBlockingQueue<SelectionKey>(500);
    43. threadPool =Executors.newFixedThreadPool(10);
    44. for(int i =0; i <10; i++){
    45. threadPool.submit(newWorker());
    46. }
    47. }
    49. privatestaticvoid 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. privatestaticvoid handleRequest(SelectionKey key)
    69. throwsIOException,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. elseif(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("服务端接收请求："+newString(buffer.array(),0, count));
    97. channel.register(selector,SelectionKey.OP_WRITE);
    98. }
    99. }elseif(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. staticclassWorkerimplementsRunnable{
    120. @Override
    121. publicvoid 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. privatevoid handleRequest(SelectionKey key)
    133. throwsIOException,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. elseif(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("服务端接收请求："+newString(buffer.array(),0, count));
    164. channel.register(selector,SelectionKey.OP_WRITE);
    165. }
    166. }elseif(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通讯其实有很多的的东西，在中间件的研发过程中使用的频率还是非常高的，后续有机会再和大家分享交流。
    本站所有文章均由网友分享，仅用于参考学习用，请勿直接转载，如有侵权，请联系网站客服删除相关文章。若由于商用引起版权纠纷，一切责任均由使用者承担
    极客文库 » 10个最高频的Java NIO面试题剖析！

    常见问题FAQ

    如果资源链接失效了怎么办?
    本站用户分享的所有资源都有自动备份机制，如果资源链接失效，请联系本站客服QQ：2580505920更新资源地址。
    如果用户分享的资源与描述不符怎么办？
    可以联系客服QQ：2580505920，如果要求合理可以安排退款或者退赞助积分。
    如何分享个人资源获取赞助积分或其他奖励？
    本站用户可以分享自己的资源，但是必须保证资源没有侵权行为。点击个人中心，根据操作填写并上传即可。资源所获收益完全归属上传者，每周可申请提现一次。
    如果您发现了本资源有侵权行为怎么办？
    及时联系客服QQ：2580505920，核实予以删除。
    多啦H梦

    多啦H梦 普通

    分享到：

    相关推荐

    参与讨论

    • 211会员总数(位)
    • 3737资源总数(个)
    • 0本周发布(个)
    • 0 今日发布(个)
    • 869稳定运行(天)

    欢迎加入「极客文库」，成为原创作者从这里开始！

    立即加入 了解更多
    成为赞助用户享有更多特权立即升级
    QQ登录