java nio(non-blocking io)简介及和io

在 Java1.4之前的I/O系统中，提供的都是面向流的I/O系统，系统一次一个字节地处理数据，一个输入流产生一个字节的数据，一个输出流消费一个字节 的数据，面向流的I/O速度非常慢，而在Java 1.4中推出了NIO，这是一个面向块的I/O系统，系统以块的方式处理处理，每一个操作在一步中产生或者消费一个数据库，按块处理要比按字节处理数据快 的多。

在NIO中有几个核心对象需要掌握：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。

缓冲区Buffer

缓冲区实际上是一个容器对象，更直接的说，其实就是一个数组，在NIO库中，所有数据都是用缓冲区处理的。在读取数据时，它是直接读到缓冲区中的； 在写入数据时，它也是写入到缓冲区中的；任何时候访问 NIO 中的数据，都是将它放到缓冲区中。而在面向流I/O系统中，所有数据都是直接写入或者直接将数据读取到Stream对象中。

在NIO中，所有的缓冲区类型都继承于抽象类Buffer，最常用的就是ByteBuffer，对于Java中的基本类型，基本都有一个具体Buffer类型与之相对应，它们之间的继承关系如下图所示：

下面是一个简单的使用IntBuffer的例子：

1. import java.nio.IntBuffer;
2. public class TestIntBuffer {
3. public static void main(String[] args) {
4. // 分配新的int缓冲区，参数为缓冲区容量
5. // 新缓冲区的当前位置将为零，其界限(限制位置)将为其容量。它将具有一个底层实现数组，其数组偏移量将为零。
6. IntBuffer buffer = IntBuffer.allocate(8);
7. for (int i = 0; i < buffer.capacity(); ++i) {
8. int j = 2 * (i + 1);
9. // 将给定整数写入此缓冲区的当前位置，当前位置递增
10. buffer.put(j);
11. }
12. // 重设此缓冲区，将限制设置为当前位置，然后将当前位置设置为0
13. buffer.flip();
14. // 查看在当前位置和限制位置之间是否有元素
15. while (buffer.hasRemaining()) {
16. // 读取此缓冲区当前位置的整数，然后当前位置递增
17. int j = buffer.get();
18. System.out.print(j + "  ");
19. }
20. }
21. }

运行后可以看到：

在后面我们还会继续分析Buffer对象，以及它的几个重要的属性。

通道Channel

通道是一个对象，通过它可以读取和写入数据，当然了所有数据都通过Buffer对象来处理。我们永远不会将字节直接写入通道中，相反是将数据写入包含一个或者多个字节的缓冲区。同样不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。

在NIO中，提供了多种通道对象，而所有的通道对象都实现了Channel接口。它们之间的继承关系如下图所示：

使用NIO读取数据

在前面我们说过，任何时候读取数据，都不是直接从通道读取，而是从通道读取到缓冲区。所以使用NIO读取数据可以分为下面三个步骤：
1. 从FileInputStream获取Channel
2. 创建Buffer
3. 将数据从Channel读取到Buffer中

下面是一个简单的使用NIO从文件中读取数据的例子：

1. import java.io.*;
2. import java.nio.*;
3. import java.nio.channels.*;
4. public class Program {
5. static public void main( String args[] ) throws Exception {
6. FileInputStream fin = new FileInputStream("c:\\test.txt");
7. // 获取通道
8. FileChannel fc = fin.getChannel();
9. // 创建缓冲区
10. ByteBuffer buffer = ByteBuffer.allocate(1024);
11. // 读取数据到缓冲区
12. fc.read(buffer);
13. buffer.flip();
14. while (buffer.remaining()>0) {
15. byte b = buffer.get();
16. System.out.print(((char)b));
17. }
18. fin.close();
19. }
20. }

使用NIO写入数据

使用NIO写入数据与读取数据的过程类似，同样数据不是直接写入通道，而是写入缓冲区，可以分为下面三个步骤：
1. 从FileInputStream获取Channel
2. 创建Buffer
3. 将数据从Channel写入到Buffer中

下面是一个简单的使用NIO向文件中写入数据的例子：

1. import java.io.*;
2. import java.nio.*;
3. import java.nio.channels.*;
4. public class Program {
5. static private final byte message[] = { 83, 111, 109, 101, 32,
6. 98, 121, 116, 101, 115, 46 };
7. static public void main( String args[] ) throws Exception {
8. FileOutputStream fout = new FileOutputStream( "c:\\test.txt" );
9. FileChannel fc = fout.getChannel();
10. ByteBuffer buffer = ByteBuffer.allocate( 1024 );
11. for (int i=0; i<message.length; ++i) {
12. buffer.put( message[i] );
13. }
14. buffer.flip();
15. fc.write( buffer );
16. fout.close();
17. }
18. }

本文介绍了Java NIO中三个核心概念中的两个，并且看了两个简单的示例，分别是使用NIO进行数据的读取和写入，Java NIO中最重要的一块Nonblocking I/O将在第三篇中进行分析，下篇将会介绍Buffer内部实现。

个别参数解释：

position：指定了下一个将要被写入或者读取的元素索引，它的值由get()/put()方法自动更新，在新0

创建一个Buffer对象时，position被初始化为0。

limit：指定还有多少数据需要取出(在从缓冲区写入通道时)，或者还有多少空间可以放入数据(在从通道读入缓冲区时)。

capacity：指定了可以存储在缓冲区中的最大数据容量，实际上，它指定了底层数组的大小，或者至少是指定了准许我们使用的底层数组的容量。

以上四个属性值之间有一些相对大小的关系：0 <= position <= limit <= capacity。如果我们创建一个新的容量大小为10的ByteBuffer对象，在初始化的时候，position设置为0，limit和 capacity被设置为10，在以后使用ByteBuffer对象过程中，capacity的值不会再发生变化，而其它两个个将会随着使用而变化。

-------------------------------Channel与io 区别----------------------------------

Channel是一个对象，可以通过它读取和写入数据。拿 NIO 与原来的 I/O 做个比较，通道就像是流，而且他们面向缓冲区的。

正如前面提到的，所有数据都通过 Buffer 对象来处理。您永远不会将字节直接写入通道中，相反，您是将数据写入包含一个或者多个字节的缓冲区。同样，您不会直接从通道中读取字节，而是将数据从通道读入缓冲区，再从缓冲区获取这个字节。

通道与流的不同之处在于通道是双向的。而流只是在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)， 而 通道 可以用于读、写或者同时用于读写。

因为它们是双向的，所以通道可以比流更好地反映底层操作系统的真实情况。特别是在 UNIX 模型中，底层操作系统通道是双向的。