转载：https://mp.weixin.qq.com/s/YIcXaH7AWLJbPjnTUwnlyQ

首先我们分别画图来看看，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. NIOServer端和Client端代码案例

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

  • NIO通讯Client端

  1. import java.io.IOException;
  2.  
  3. import java.net.InetSocketAddress;
  4.  
  5. import java.nio.ByteBuffer;
  6.  
  7. import java.nio.channels.SelectionKey;
  8.  
  9. import java.nio.channels.Selector;
  10.  
  11. import java.nio.channels.SocketChannel;
  12.  
  13. import java.util.Iterator;
  14.  
  15. public class NIOClient {
  16.  
  17. 　　public static void main(String[] args) { 
  18.  
  19. 　　　　for(int i = 0; i < 10; i++){ 
  20.  
  21. 　　　　　　new Worker().start(); 
  22.  
  23. 　　　　} 
  24.  
  25. 　　} 
  26.  
  27. 　　static class Worker extends Thread {
  28.  
  29. 　　@Override 
  30.  
  31. 　　　public void run() { 
  32.  
  33. SocketChannel channel = null; 
  34.  
  35. Selector selector = null; 
  36.  
  37. try { 
  38.  
  39. // SocketChannel，一看底层就是封装了一个Socket
  40.  
  41. channel = SocketChannel.open(); // SocketChannel是连接到底层的Socket网络
  42.  
  43. // 数据通道就是负责基于网络读写数据的
  44.  
  45. channel.configureBlocking(false); 
  46.  
  47. channel.connect(new InetSocketAddress("localhost", 9000)); 
  48.  
  49. // 后台一定是tcp三次握手建立网络连接
  50.  
  51. selector = Selector.open(); 
  52.  
  53. // 监听Connect这个行为
  54.  
  55. channel.register(selector, SelectionKey.OP_CONNECT); 
  56.  
  57. while(true){ 
  58.  
  59. // selector多路复用机制的实现 循环去遍历各个注册的Channel
  60.  
  61. selector.select(); 
  62.  
  63. Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator(); 
  64.  
  65. while(keysIterator.hasNext()){ 
  66.  
  67. SelectionKey key = (SelectionKey) keysIterator.next(); 
  68.  
  69. keysIterator.remove(); 
  70.  
  71. // 如果发现返回的时候一个可连接的消息 走到下面去接受数据
  72.  
  73. if(key.isConnectable()){ channel = (SocketChannel) key.channel(); 
  74.  
  75. if(channel.isConnectionPending()){ 
  76.  
  77. channel.finishConnect();
  78.  
  79. // 接下来对这个SocketChannel感兴趣的就是人家server给你发送过来的数据了
  80.  
  81. // READ事件，就是可以读数据的事件
  82.  
  83. // 一旦建立连接成功了以后，此时就可以给server发送一个请求了
  84.  
  85. ByteBuffer buffer = ByteBuffer.allocate(1024);
  86.  
  87. buffer.put("你好".getBytes());
  88.  
  89. buffer.flip();
  90.  
  91. channel.write(buffer); 
  92.  
  93. } 
  94.  
  95. channel.register(selector, SelectionKey.OP_READ);
  96.  
  97. } 
  98.  
  99. // 这里的话就时候名服务器端返回了一条数据可以读了
  100.  
  101. else if(key.isReadable()){ channel = (SocketChannel) key.channel();
  102.  
  103. // 构建一个缓冲区
  104.  
  105. ByteBuffer buffer = ByteBuffer.allocate(1024); 
  106.  
  107. // 把数据写入buffer，position推进到读取的字节数数字
  108.  
  109. int len = channel.read(buffer); 
  110.  
  111. if(len > 0) {
  112.  
  113. System.out.println("[" + Thread.currentThread().getName() 
  114.  
  115. + "]收到响应：" + new String(buffer.array(), 0, len)); 
  116.  
  117. Thread.sleep(5000); 
  118.  
  119. channel.register(selector, SelectionKey.OP_WRITE);
  120.  
  121. }
  122.  
  123. } else if(key.isWritable()) {
  124.  
  125. ByteBuffer buffer = ByteBuffer.allocate(1024);
  126.  
  127. buffer.put("你好".getBytes());
  128.  
  129. buffer.flip();
  130.  
  131. channel = (SocketChannel) key.channel();
  132.  
  133. channel.write(buffer); 
  134.  
  135. channel.register(selector, SelectionKey.OP_READ);
  136.  
  137. } 
  138.  
  139. } 
  140.  
  141. } 
  142.  
  143. } catch (Exception e) { 
  144.  
  145. e.printStackTrace(); 
  146.  
  147. } finally{ 
  148.  
  149. if(channel != null){ 
  150.  
  151. try { 
  152.  
  153. channel.close(); 
  154.  
  155. } catch (IOException e) { 
  156.  
  157. e.printStackTrace(); 
  158.  
  159. } 
  160.  
  161. } 
  162.  
  163. if(selector != null){ 
  164.  
  165. try { 
  166.  
  167. selector.close(); 
  168.  
  169. } catch (IOException e) { 
  170.  
  171. e.printStackTrace(); 
  172.  
  173. } 
  174.  
  175. } 
  176.  
  177. } 
  178.  
  179. } 
  180.  
  181. }
  182.  
  183. }

  • NIO通讯Server端

  1. } 
  2.  
  3. }
  4.  
  5. }
  6.  
  7. NIO通讯Server端
  8.  
  9. import java.io.IOException;
  10.  
  11. import java.net.InetSocketAddress;
  12.  
  13. import java.nio.ByteBuffer;
  14.  
  15. import java.nio.channels.ClosedChannelException;
  16.  
  17. import java.nio.channels.SelectionKey;
  18.  
  19. import java.nio.channels.Selector;
  20.  
  21. import java.nio.channels.ServerSocketChannel;
  22.  
  23. import java.nio.channels.SocketChannel;
  24.  
  25. import java.util.Iterator;
  26.  
  27. import java.util.concurrent.ExecutorService;
  28.  
  29. import java.util.concurrent.Executors;
  30.  
  31. import java.util.concurrent.LinkedBlockingQueue;
  32.  
  33. public class NIOServer {
  34.  
  35. private static Selector selector; 
  36.  
  37. private static LinkedBlockingQueue<SelectionKey> requestQueue;
  38.  
  39. private static ExecutorService threadPool;
  40.  
  41. public static void main(String[] args) {
  42.  
  43. init();
  44.  
  45. listen();
  46.  
  47. } 
  48.  
  49. private static void init(){ 
  50.  
  51. ServerSocketChannel serverSocketChannel = null; 
  52.  
  53. try { 
  54.  
  55. selector = Selector.open();
  56.  
  57. serverSocketChannel = ServerSocketChannel.open(); 
  58.  
  59. // 将Channel设置为非阻塞的 NIO就是支持非阻塞的
  60.  
  61. serverSocketChannel.configureBlocking(false); serverSocketChannel.socket().bind(new InetSocketAddress(), ); 
  62.  
  63. // ServerSocket，就是负责去跟各个客户端连接连接请求的
  64.  
  65. serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT); 
  66.  
  67. // 就是仅仅关注这个ServerSocketChannel接收到的TCP连接的请求
  68.  
  69. } catch (IOException e) { 
  70.  
  71. e.printStackTrace(); 
  72.  
  73. } 
  74.  
  75. requestQueue = new LinkedBlockingQueue<SelectionKey>();
  76.  
  77. threadPool = Executors.newFixedThreadPool();
  78.  
  79. for(int i = ; i < ; i++) {
  80.  
  81. threadPool.submit(new Worker()); 
  82.  
  83. }
  84.  
  85. } 
  86.  
  87. private static void listen() { 
  88.  
  89. while(true){ 
  90.  
  91. try{ 
  92.  
  93. selector.select(); 
  94.  
  95. Iterator<SelectionKey> keysIterator = selector.selectedKeys().iterator(); 
  96.  
  97. while(keysIterator.hasNext()){ 
  98.  
  99. SelectionKey key = (SelectionKey) keysIterator.next(); 
  100.  
  101. // 可以认为一个SelectionKey是代表了一个请求
  102.  
  103. keysIterator.remove();
  104.  
  105. handleRequest(key);
  106.  
  107. } 
  108.  
  109. } 
  110.  
  111. catch(Throwable t){ 
  112.  
  113. t.printStackTrace(); 
  114.  
  115. } 
  116.  
  117. } 
  118.  
  119. } 
  120.  
  121. private static void handleRequest(SelectionKey key) 
  122.  
  123. throws IOException, ClosedChannelException { 
  124.  
  125. // 后台的线程池中的线程处理下面的代码逻辑
  126.  
  127. SocketChannel channel = null; 
  128.  
  129. try{ 
  130.  
  131. // 如果说这个Key是一个acceptable,也就是一个连接请求
  132.  
  133. if(key.isAcceptable()){ 
  134.  
  135. ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel(); 
  136.  
  137. // 调用accept这个方法 就可以进行TCP三次握手了
  138.  
  139. channel = serverSocketChannel.accept(); 
  140.  
  141. // 握手成功的话就可以获取到一个TCP连接好的SocketChannel
  142.  
  143. channel.configureBlocking(false); 
  144.  
  145. channel.register(selector, SelectionKey.OP_READ); 
  146.  
  147. // 仅仅关注这个READ请求，就是人家发送数据过来的请求
  148.  
  149. } 
  150.  
  151. // 如果说这个key是readable，是个发送了数据过来的话，此时需要读取客户端发送过来的数据
  152.  
  153. else if(key.isReadable()){ 
  154.  
  155. channel = (SocketChannel) key.channel(); 
  156.  
  157. ByteBuffer buffer = ByteBuffer.allocate();
  158.  
  159. int count = channel.read(buffer); 
  160.  
  161. // 通过底层的socket读取数据，写buffer中，position可能就会变成21之类的
  162.  
  163. // 你读取到了多少个字节，此时buffer的position就会变成多少
  164.  
  165. if(count > ){ 
  166.  
  167. // 准备读取刚写入的数据，就是将limit设置为当前position，将position设置为0，丢弃mark。一般就是先写入数据，接着准备从0开始读这段数据，就可以用flip
  168.  
  169. // position = 0，limit = 21，仅仅读取buffer中，0~21这段刚刚写入进去的数据
  170.  
  171. buffer.flip(); 
  172.  
  173. System.out.println("服务端接收请求：" + new String(buffer.array(), , count)); 
  174.  
  175. channel.register(selector, SelectionKey.OP_WRITE);
  176.  
  177. } 
  178.  
  179. } else if(key.isWritable()) {
  180.  
  181. ByteBuffer buffer = ByteBuffer.allocate();
  182.  
  183. buffer.put("收到".getBytes());
  184.  
  185. buffer.flip();
  186.  
  187. channel = (SocketChannel) key.channel();
  188.  
  189. channel.write(buffer); 
  190.  
  191. channel.register(selector, SelectionKey.OP_READ);
  192.  
  193. }
  194.  
  195. } 
  196.  
  197. catch(Throwable t){ 
  198.  
  199. t.printStackTrace(); 
  200.  
  201. if(channel != null){ 
  202.  
  203. channel.close(); 
  204.  
  205. } 
  206.  
  207. } 
  208.  
  209. }
  210.  
  211. // 创建一个线程任务来执行
  212.  
  213. static class Worker implements Runnable {
  214.  
  215. @Override
  216.  
  217. public void run() {
  218.  
  219. while(true) {
  220.  
  221. try {
  222.  
  223. SelectionKey key = requestQueue.take();
  224.  
  225. handleRequest(key);
  226.  
  227. } catch (Exception e) {
  228.  
  229. e.printStackTrace();
  230.  
  231. }
  232.  
  233. }
  234.  
  235. }
  236.  
  237. private void handleRequest(SelectionKey key) 
  238.  
  239. throws IOException, ClosedChannelException { 
  240.  
  241. // 假设想象一下，后台有个线程池获取到了请求
  242.  
  243. // 下面的代码，都是在后台线程池的工作线程里在处理和执行
  244.  
  245. SocketChannel channel = null; 
  246.  
  247. try{ 
  248.  
  249. // 如果说这个key是个acceptable，是个连接请求的话
  250.  
  251. if(key.isAcceptable()){ System.out.println("[" + Thread.currentThread().getName() + "]接收到连接请求"); 
  252.  
  253. ServerSocketChannel serverSocketChannel = (ServerSocketChannel) key.channel(); 
  254.  
  255. // 调用accept方法 和客户端进行三次握手
  256.  
  257. channel = serverSocketChannel.accept(); System.out.println("[" + Thread.currentThread().getName() + "]建立连接时获取到的channel=" + channel); 
  258.  
  259. // 如果三次握手成功了之后，就可以获取到一个建立好TCP连接的SocketChannel
  260.  
  261. // 这个SocketChannel大概可以理解为，底层有一个Socket，是跟客户端进行连接的
  262.  
  263. // 你的SocketChannel就是联通到那个Socket上去，负责进行网络数据的读写的
  264.  
  265. // 设置为非阻塞的
  266.  
  267. channel.configureBlocking(false); 
  268.  
  269. // 关注的是Reade请求
  270.  
  271. channel.register(selector, SelectionKey.OP_READ); } 
  272.  
  273. // 如果说这个key是readable，是个发送了数据过来的话，此时需要读取客户端发送过来的数据
  274.  
  275. else if(key.isReadable()){ 
  276.  
  277. channel = (SocketChannel) key.channel(); 
  278.  
  279. ByteBuffer buffer = ByteBuffer.allocate();
  280.  
  281. int count = channel.read(buffer); 
  282.  
  283. // 通过底层的socket读取数据，写入buffer中，position可能就会变成21之类的
  284.  
  285. // 你读取到了多少个字节，此时buffer的position就会变成多少
  286.  
  287. System.out.println("[" + Thread.currentThread().getName() + "]接收到请求"); 
  288.  
  289. if(count > ){ 
  290.  
  291. buffer.flip(); // position = 0，limit = 21，仅仅读取buffer中，0~21这段刚刚写入进去的数据
  292.  
  293. System.out.println("服务端接收请求：" + new String(buffer.array(), , count)); 
  294.  
  295. channel.register(selector, SelectionKey.OP_WRITE);
  296.  
  297. } 
  298.  
  299. } else if(key.isWritable()) {
  300.  
  301. ByteBuffer buffer = ByteBuffer.allocate();
  302.  
  303. buffer.put("收到".getBytes());
  304.  
  305. buffer.flip();
  306.  
  307. channel = (SocketChannel) key.channel();
  308.  
  309. channel.write(buffer); 
  310.  
  311. channel.register(selector, SelectionKey.OP_READ);
  312.  
  313. }
  314.  
  315. } 
  316.  
  317. catch(Throwable t){ 
  318.  
  319. t.printStackTrace(); 
  320.  
  321. if(channel != null){ 
  322.  
  323. channel.close(); 
  324.  
  325. } 
  326.  
  327. } 
  328.  
  329. }
  330.  
  331. }
  332.  
  333. }

总结:

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

  • BIO， NIO， AIO各自的特点

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

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

  • NIO相关组件的原理

  • NIO通讯的简单案例

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

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

java NIO面试题剖析的更多相关文章

  1. Java面试炼金系列 (1) | 关于String类的常见面试题剖析

    Java面试炼金系列 (1) | 关于String类的常见面试题剖析 文章以及源代码已被收录到:https://github.com/mio4/Java-Gold 0x0 基础知识 1. '==' 运 ...

  2. Java NIO：IO与NIO的区别 -阿里面试题

    一.概念 NIO即New IO,这个库是在JDK1.4中才引入的.NIO和IO有相同的作用和目的,但实现方式不同,NIO主要用到的是块,所以NIO的效率要比IO高很多.在Java API中提供了两套N ...

  3. java NIO、BIO、AIO全面剖析

    在高性能的IO体系设计中,有几个名词概念常常会使我们感到迷惑不解.具体如下: 序号 问题 1 什么是同步? 2 什么是异步? 3 什么是阻塞? 4 什么是非阻塞? 5 什么是同步阻塞? 6 什么是同步 ...

  4. JAVA常见面试题及解答

    JAVA相关基础知识1.面向对象的特征有哪些方面 1.抽象:抽象就是忽略一个主题中与当前目标无关的那些方面,以便更充分地注意与当前目标有关的方面.抽象并不打算了解全部问题,而只是选择其中的一部分,暂时 ...

  5. Java 200+ 面试题补充② Netty 模块

    让我们每天都能看到自己的进步.老王带你打造最全的 Java 面试清单,认真把一件事做到最好. 本文是前文<Java 最常见的 200+ 面试题>的第二个补充模块,第一模块为:<Jav ...

  6. Java NIO之Selector（选择器）

    历史回顾: Java NIO 概览 Java NIO 之 Buffer(缓冲区) Java NIO 之 Channel(通道) 其他高赞文章: 面试中关于Redis的问题看这篇就够了 一文轻松搞懂re ...

  7. Java高级面试题解析（一）

    最近,在看一些java高级面试题,我发现我在认真研究一个面试题的时候,我自己的收获是很大的,我们在看看面试题的时候,不仅仅要看这个问题本身,还要看这个问题的衍生问题,一个问题有些时候可能是一个问题群( ...

  8. Java笔试面试题整理第四波

    转载至:http://blog.csdn.net/shakespeare001/article/details/51274685 作者:山代王(开心阳) 本系列整理Java相关的笔试面试知识点,其他几 ...

  9. Java 虚拟机面试题全面解析（干货）

    Java 虚拟机面试题全面解析(干货) JDK 是什么 JRE 是什么 Java历史版本的特性 Java Version SE 50 Java Version SE 6 Java Version SE ...

随机推荐

  1. MTSC2019-深圳站 议题征集

    议题截止时间 11月初 议题投递地址 topic@testerhome.com   臣一路走来,没有敌人,看见的都是朋友和师长 —司马懿 关于中国移动互联网测试大会 MTSC 大会(中国移动互联网测试 ...

  2. Android P(9.0) userdebug版本执行adb remount失败

    [DESCRIPTION]      在android P版本上如果按照“FAQ18076 android 6.0 M userdebug版本执行adb remount失败”的做法在userdebug ...

  3. Tachyon内存文件系统快速入门

    一.简介 Tachyon是介于磁盘存储和计算框架之间的一种中间件,用于实现分布式的内存文件读写等功能,实现分布式集群内部共享数据. 应用实例: 二.架构 1.心跳机制 在Tachyon中,心跳用于Ma ...

  4. 【GitHub】源代码管理工具初识

    软件工程综合实践第四次个人作业 作业要求:通过搜索资料和自学,了解源代码管理工具——GitHub 前言: GitHub,读音 /git·hʌb/ ,让社会化编程成为现实,其于2018年6月4日被微软收 ...

  5. JVM 理论基础目录(待更新，系列完全写完后会统一整理好)

    参考文档: [1] Java 虚拟机规范(Java SE 8版) [2] 深入理解 Java 虚拟机: JVM 高级特性与最佳实践 周志明 本系列的更新快慢全部随意,介意者请海涵. 一 .JVM 入门 ...

  6. ELK快速入门（二）通过logstash收集日志

    ELK快速入门二-通过logstash收集日志 说明 这里的环境接着上面的ELK快速入门-基本部署文章继续下面的操作. 收集多个日志文件 1)logstash配置文件编写 [root@linux-el ...

  7. C++学习（10）—— 对象模型和this指针

    1. 成员变量和成员函数分开存储 在C++中,类内的成员变量和成员函数分开存储 只有非静态成员变量才属于类的对象上 空对象占用内存空间为1 C++编译器会给每个空对象也分配一个字节空间,是为了区分空对 ...

  8. Java精通并发-Lock锁方法原理详解

    继续上一次https://www.cnblogs.com/webor2006/p/11756563.html的Lock文档说明进行阅读: 以上就是对于Lock类中官方解读,下面再纵览一下它里面的方法: ...

  9. js事件3-事件对象

    对于每次点击一个事件,都会产生一个事件对象,这个事件对象中包含了这个事件的很多信息 我们来看看事件对象具体有哪些信息 Object.onclick=function(e){ ..... }其中的参数e ...

  10. python爬虫中遇到的问题以及解决方法

    (1)运行后报错:“TypeError: cannot use a string pattern on a bytes-like” 原因:content用decode(‘utf-8’)进行解码,由by ...