Java NIO

秒速五厘米 2022-07-14 15:14 141阅读 0赞

**1.[Java ][Java]NIO 由以下几个核心部分组成：**

*  Channels
 *  Buffers
 *  Selectors

虽然Java NIO 中除此之外还有很多类和组件，但在我看来，Channel，Buffer 和 Selector 构成了核心的API。其它组件，如Pipe和FileLock，只不过是与三个核心组件共同使用的工具类。因此，在概述中我将集中在这三个组件上。其它组件会在单独的章节中讲到。   
  
Channel 和 Buffer    
  
基本上，所有的 IO 在NIO 中都从一个Channel 开始。Channel 有点象流。 数据可以从Channel读到Buffer中，也可以从Buffer 写到Channel中。这里有个图示：

![e20c73df-9ade-3121-be5f-307e6baf328f.png][]

Selector    
  
Selector允许单线程处理多个 Channel。如果你的应用打开了多个连接（通道），但每个连接的流量都很低，使用Selector就会很方便。例如，在一个聊天服务器中。   
  
这是在一个单线程中使用一个Selector处理3个Channel的图示：

![79224e12-3615-3917-9e85-42e7edbd8b40.png][]

要使用Selector，得向Selector注册Channel，然后调用它的select()方法。这个方法会一直阻塞到某个注册的通道有事件就绪。一旦这个方法返回，线程就可以处理这些事件，事件的例子有如新连接进来，数据接收等。

**2.Java NIO和IO的主要区别 **

下表总结了Java NIO和IO之间的主要差别，我会更详细地描述表中每部分的差异。

<table style="border:1px solid rgb(204,204,204); color:rgb(0,0,0); font-family:Helvetica,Tahoma,Arial,sans-serif; font-size:14px; line-height:22.4px"> 
 <tbody> 
 <tr> 
 <td style="font-size:1em; border:1px solid rgb(204,204,204); padding:3px">IO</td> 
 <td style="font-size:1em; border:1px solid rgb(204,204,204); padding:3px">NIO</td> 
 </tr> 
 <tr> 
 <td style="font-size:1em; border:1px solid rgb(204,204,204); padding:3px">Stream oriented</td> 
 <td style="font-size:1em; border:1px solid rgb(204,204,204); padding:3px">Buffer oriented</td> 
 </tr> 
 <tr> 
 <td style="font-size:1em; border:1px solid rgb(204,204,204); padding:3px">Blocking IO</td> 
 <td style="font-size:1em; border:1px solid rgb(204,204,204); padding:3px">Non blocking IO</td> 
 </tr> 
 <tr> 
 <td style="font-size:1em; border:1px solid rgb(204,204,204); padding:3px"> </td> 
 <td style="font-size:1em; border:1px solid rgb(204,204,204); padding:3px">Selectors</td> 
 </tr> 
 </tbody> 
</table>

面向流与面向缓冲    
  
Java NIO和IO之间第一个最大的区别是，IO是面向流的，NIO是面向缓冲区的。 Java IO面向流意味着每次从流中读一个或多个字节，直至读取所有字节，它们没有被缓存在任何地方。此外，它不能前后移动流中的数据。如果需要前后移动从流中读取的数据，需要先将它缓存到一个缓冲区。 Java NIO的缓冲导向方法略有不同。数据读取到一个它稍后处理的缓冲区，需要时可在缓冲区中前后移动。这就增加了处理过程中的灵活性。但是，还需要检查是否该缓冲区中包含所有您需要处理的数据。而且，需确保当更多的数据读入缓冲区时，不要覆盖缓冲区里尚未处理的数据。   
  
阻塞与非阻塞IO    
  
Java IO的各种流是阻塞的。这意味着，当一个线程调用read() 或 write()时，该线程被阻塞，直到有一些数据被读取，或数据完全写入。该线程在此期间不能再干任何事情了。 Java NIO的非阻塞模式，使一个线程从某通道发送请求读取数据，但是它仅能得到目前可用的数据，如果目前没有数据可用时，就什么都不会获取。而不是保持线程阻塞，所以直至数据变的可以读取之前，该线程可以继续做其他的事情。 非阻塞写也是如此。一个线程请求写入一些数据到某通道，但不需要等待它完全写入，这个线程同时可以去做别的事情。 线程通常将非阻塞IO的空闲时间用于在其它通道上执行IO操作，所以一个单独的线程现在可以管理多个输入和输出通道（channel）。   
  
选择器（Selectors）    
  
Java NIO的选择器允许一个单独的线程来监视多个输入通道，你可以注册多个通道使用一个选择器，然后使用一个单独的线程来“选择”通道：这些通道里已经有可以处理的输入，或者选择已准备写入的通道。这种选择机制，使得一个单独的线程很容易来管理多个通道。

总结   
  
NIO可让您只使用一个（或几个）单线程管理多个通道（网络连接或文件），但付出的代价是解析数据可能会比从一个阻塞流中读取数据更复杂。   
  
如果需要管理同时打开的成千上万个连接，这些连接每次只是发送少量的数据，例如聊天服务器，实现NIO的服务器可能是一个优势。同样，如果你需要维持许多打开的连接到其他计算机上，如P2P网络中，使用一个单独的线程来管理你所有出站连接，可能是一个优势。一个线程多个连接的设计方案如下图所示：

![8c8b13c9-0d38-3599-99d3-e0d1aa90589d.png][]   
单线程管理多个连接

如果你有少量的连接使用非常高的带宽，一次发送大量的数据，也许典型的IO服务器实现可能非常契合。下图说明了一个典型的IO服务器设计：

![72c44e71-8219-3989-a787-b67ced3c7ab1.png][]   
一个典型的IO服务器设计：一个连接通过一个线程处理

**3.缓冲区(Buffer)**

缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。   
  
Buffer的基本用法   
  
**使用Buffer读写数据一般遵循以下四个步骤： **

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

Buffer的capacity,position和limit    
  
缓冲区本质上是一块可以写入数据，然后可以从中读取数据的内存。这块内存被包装成NIO Buffer对象，并提供了一组方法，用来方便的访问该块内存。   
  
为了理解Buffer的工作原理，需要熟悉它的三个属性：

*  capacity
 *  position
 *  limit

position和limit的含义取决于Buffer处在读模式还是写模式。不管Buffer处在什么模式，capacity的含义总是一样的。

这里有一个关于capacity，position和limit在读写模式中的说明，详细的解释在插图后面。

![b8a7bad8-ec65-36dc-bb11-4f352e00cd67.png][]

capacity    
  
作为一个内存块，Buffer有一个固定的大小值，也叫“capacity”.你只能往里写capacity个byte、long，char等类型。一旦Buffer满了，需要将其清空（通过读数据或者清除数据）才能继续写数据往里写数据。   
  
position    
  
当你写数据到Buffer中时，position表示当前的位置。初始的position值为0.当一个byte、long等数据写到Buffer后， position会向前移动到下一个可插入数据的Buffer单元。position最大可为capacity – 1。   
  
当读取数据时，也是从某个特定位置读。当将Buffer从写模式切换到读模式，position会被重置为0。当从Buffer的position处读取数据时，position向前移动到下一个可读的位置。   
  
limit    
  
在写模式下，Buffer的limit表示你最多能往Buffer里写多少数据。 写模式下，limit等于Buffer的capacity。   
  
当切换Buffer到读模式时， limit表示你最多能读到多少数据。因此，当切换Buffer到读模式时，limit会被设置成写模式下的position值。换句话说，你能读到之前写入的所有数据（limit被设置成已写数据的数量，这个值在写模式下就是position）

**Buffer的[测试][Link 1]代码**

**\[java\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1. **public** **class** BufferTest \{  
2.   
3.     // 测试flip()函数  
4.     **public** **void** testFlip() \{  
5.   
6.         // 创建指定长度的缓冲区  
7.         IntBuffer buf = IntBuffer.allocate(10);  
8.         buf.put(13);// position位置：0 - > 1  
9.         buf.put(21);// position位置：1 - > 2  
10.         buf.put(35);// position位置：2 - > 3  
11.         buf.put(36);// position位置：3 - > 4  
12.         // 打印执行flip()函数之前，字节数组的信息  
13.         System.out.println("使用flip复位前的信息：" + buf);  
14.         // 使用flip(),使得字节数组进入读模式  
15.         // 把位置复位为0，也就是position=0;并且limit=position(之前的position位置)  
16.         buf.flip();  
17.         System.out.println("使用flip复位后的信息：" + buf);  
18.         // 容量一旦初始化后不允许改变（warp方法包裹数组除外）  
19.         System.out.println("容量为: " + buf.capacity());  
20.         // 由于只装载了三个元素,所以可读取或者操作的元素为3,  
21.         // 则limit=3  
22.         System.out.println("限制为: " + buf.limit());  
23.   
24.     \}  
25.   
26.     // 关于字节数组，position是否改变  
27.     // buf.put() buf.get() position的数值，会进行加1的操作  
28.     // buf.put(index,value) buf.get(index) position的数值，不会改变  
29.     **public** **void** testPosition() \{  
30.         // 创建指定长度的缓冲区  
31.         IntBuffer buf = IntBuffer.allocate(10);  
32.         buf.put(13);// position位置：0 - > 1  
33.         buf.put(21);// position位置：1 - > 2  
34.         buf.put(35);// position位置：2 - > 3  
35.         System.out.println(buf);  
36.         buf.put(2, 36); // position位置不变  
37.         System.out.println(buf);  
38.         System.out.println(buf.get(2));// position位置不变  
39.         System.out.println(buf);  
40.         System.out.println();  
41.         // 进入读模式，读取数据  
42.         buf.flip();  
43.         System.out.println(buf);  
44.         **for** (**int** i = 0; i < buf.limit(); i++) \{  
45.             System.out.println(buf.get());// position位置,会加1  
46.             System.out.println(buf);  
47.         \}  
48.     \}  
49.   
50.     **public** **void** testWarp() \{  
51.   
52.         // wrap方法会包裹一个数组  
53.         // 一般这种用法不会先初始化缓存对象的长度，因为没有意义，最后还会被wrap所包裹的数组覆盖掉。  
54.         // 并且wrap方法修改缓冲区对象的时候，数组本身也会跟着发生变化。  
55.         **int**\[\] arr = **new** **int**\[\] \{ 1, 2, 5 \};  
56.         IntBuffer buf1 = IntBuffer.wrap(arr);  
57.         System.out.println(buf1);  
58.         // 这样使用表示容量为数组arr的长度  
59.         // 但是可操作的元素只有实际进入缓存区的元素长度  
60.         IntBuffer buf2 = IntBuffer.wrap(arr, 0, 2);  
61.         buf2.remaining();  
62.         System.out.println(buf2);  
63.   
64.     \}  
65.   
66.     **public** **void** testRemaining() \{  
67.         IntBuffer buf = IntBuffer.allocate(10);  
68.         buf.put(13);// position位置：0 - > 1  
69.         buf.put(21);// position位置：1 - > 2  
70.         buf.put(35);// position位置：2 - > 3  
71.         // 进入读模式  
72.         buf.flip();  
73.         System.out.println("可读数据为：" + buf.remaining());  
74.         // 将缓冲区数据放入arr2数组中去  
75.         **int**\[\] arr2 = **new** **int**\[buf.remaining()\];  
76.         buf.get(arr2);  
77.         **for** (**int** i : arr2) \{  
78.             System.out.print(Integer.toString(i) + ",");  
79.         \}  
80.     \}  
81.   
82.     **public** **static** **void** main(String\[\] args) \{  
83.   
84.         **new** BufferTest().testRemaining();  
85.   
86.     \}  
87. \}

参考博客

**\[java\]**  [view plain][]   [copy][view plain]

[print][view plain] [?][view plain] [![在CODE上查看代码片][CODE]][CODE_CODE] [![派生到我的代码片][ico_fork.svg]][ico_fork.svg 1]

1.  http://ifeve.com/overview/  
2.  http://www.iteye.com/magazines/132-Java-NIO

[Java]: http://lib.csdn.net/base/java
[e20c73df-9ade-3121-be5f-307e6baf328f.png]: /images/20220714/58d7c21d804f4fe5b7a0792d5ebb94ff.png
[79224e12-3615-3917-9e85-42e7edbd8b40.png]: /images/20220714/eba477a6001c4f3bb4a5ef629ebd263f.png
[8c8b13c9-0d38-3599-99d3-e0d1aa90589d.png]: /images/20220714/c6a4658be4714c6f95844c1d6aa307d0.png
[72c44e71-8219-3989-a787-b67ced3c7ab1.png]: /images/20220714/b6bc2608f808497b8b95ea65a3bafcb3.png
[b8a7bad8-ec65-36dc-bb11-4f352e00cd67.png]: /images/20220714/0b014f126e64418ab506c67c83c93d28.png
[Link 1]: http://lib.csdn.net/base/softwaretest
[view plain]: http://blog.csdn.net/zbw18297786698/article/details/53572755#
[CODE]: https://code.csdn.net/assets/CODE_ico.png
[CODE_CODE]: https://code.csdn.net/snippets/2043293
[ico_fork.svg]: https://code.csdn.net/assets/ico_fork.svg
[ico_fork.svg 1]: https://code.csdn.net/snippets/2043293/fork