Java NIO

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

• Channels
• Buffers
• Selectors

虽然Java NIO 中除此之外还有很多类和组件，但在我看来，Channel，Buffer 和 Selector 构成了核心的API。其它组件，如Pipe和FileLock，只不过是与三个核心组件共同使用的工具类。因此，在概述中我将集中在这三个组件上。其它组件会在单独的章节中讲到。 

Channel 和 Buffer  

基本上，所有的 IO 在NIO 中都从一个Channel 开始。Channel 有点象流。 数据可以从Channel读到Buffer中，也可以从Buffer 写到Channel中。这里有个图示： 

Selector  

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

这是在一个单线程中使用一个Selector处理3个Channel的图示： 

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

2.Java NIO和IO的主要区别 

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

IO	NIO
Stream oriented	Buffer oriented
Blocking IO	Non blocking IO
	Selectors

面向流与面向缓冲  

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网络中，使用一个单独的线程来管理你所有出站连接，可能是一个优势。一个线程多个连接的设计方案如下图所示： 

 
单线程管理多个连接

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

 
一个典型的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在读写模式中的说明，详细的解释在插图后面。 

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的测试代码

[java]  view plain  copy

 print ?

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

 print ?

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