Java NIO-Scott-Blog

转自：Java NIO

在 Java 1.4 之前的 IO 系统中，提供的都是面向流的 IO 系统（InputStream / OutputStream），系统一次一个字节（Byte）地处理数据，一个输入流产生一个字节的数据，一个输出流消费一个字节的数据，面向流的 IO 速度非常慢。

在 Java 1.4 推出了 NIO，这是一个面向块的 IO 系统，系统以块的方式处理。在NIO中有几个核心对象：缓冲区（Buffer）、通道（Channel）、选择器（Selector）。

Buffer

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

在 NIO 中，所有的缓冲区类型都继承于抽象类 Buffer，最常用的就是 ByteBuffer，对于 Java 的基本类型，基本都有一个具体的 Buffer 类型与之对象。

一个简单的使用 IntBuffer 的例子：

import java.nio.IntBuffer;  

public class TestIntBuffer {  

    public static void main(String[] args) {  

        // 分配新的int缓冲区，参数为缓冲区容量  

        // 新缓冲区的当前位置将为零，其界限(限制位置)将为其容量。它将具有一个底层实现数组，其数组偏移量将为零。  

        IntBuffer buffer = IntBuffer.allocate(8);  

        for (int i = 0; i < buffer.capacity();   i) {  

            int j = 2 * (i   1);  

            // 将给定整数写入此缓冲区的当前位置，当前位置递增  

            buffer.put(j);  

        }  

        // 重设此缓冲区，将限制设置为当前位置，然后将当前位置设置为0  

        buffer.flip();  

        // 查看在当前位置和限制位置之间是否有元素  

        while (buffer.hasRemaining()) {  

            // 读取此缓冲区当前位置的整数，然后当前位置递增  

            int j = buffer.get();  

            System.out.print(j   "  ");  

        }    

    }  

}

在 Buffer 中，有三个重要的属性：postion、limit、capacity。

position：指定了下一个将要被写入或者读取的元素索引，它的值由 get()/put() 方法自动更新，在新创建一个 Buffer 对象时，position 被初始化为0。

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

capacity：指定了可以存储在缓冲区中的最大数据容量，实际上，它指定了底层数组的大小。

如果创建一个新的容量大小为10的 ByteBuffer 对象，在初始化的时候，position 设置为0，limit 和 capacity 被设置为10。

现

在从通道中读取一些数据到缓冲区中，注意从通道读取数据，相当于往缓冲区中写入数据。如果读取4个自己的数据，则此时 position 的值为4，即下一个将要被写入的字节索引为4，而limit仍然是10

下一步把读取的数据写入到输出通道中，相当于从缓冲区中读取数据，在此之前，必须调用 flip() 方法，该方法将会完成两件事情：

1. 把 limit 设置为当前的position值；2. 把 position 设置为0

由于 position 被设置为0，所以可以保证在下一步输出时读取到的是缓冲区中的第一个字节，而 limit 被设置为当前的 position，可以保证读取的数据正好是之前写入到缓冲区中的数据。

现在调用 get() 方法从缓冲区中读取数据写入到输出通道，这会导致 position 的增加而 limit 保持不变，但 position 不会超过 limit 的值，所以在读取我们之前写入到缓冲区中的4个自己之后，position 和 limit 的值都为4。

在从缓冲区中读取数据完毕后，调用 clear() 方法能够把所有的状态变化设置为初始化时的值。

用一段代码来验证这个过程：

import java.io.*;  

import java.nio.*;  

import java.nio.channels.*;  

public class Program {  

    public static void main(String args[]) throws Exception {  

        FileInputStream fin = new FileInputStream("d:\\test.txt");  

        FileChannel fc = fin.getChannel();  

        ByteBuffer buffer = ByteBuffer.allocate(10);  

        output("初始化", buffer);  

        fc.read(buffer);  

        output("调用read()", buffer);  

        buffer.flip();  

        output("调用flip()", buffer);  

        while (buffer.remaining() > 0) {  

            byte b = buffer.get();  

            // System.out.print(((char)b));  

        }  

        output("调用get()", buffer);  

        buffer.clear();  

        output("调用clear()", buffer);  

        fin.close();  

    }  

    public static void output(String step, Buffer buffer) {  

        System.out.println(step   " : ");  

        System.out.print("capacity: "   buffer.capacity()   ", ");  

        System.out.print("position: "   buffer.position()   ", ");  

        System.out.println("limit: "   buffer.limit());  

        System.out.println();  

    }  

}

Channel

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

在 NIO 中，提供了多种通道对象，而所有对象都实现了 Channel 接口。

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

import java.io.*;  

import java.nio.*;  

import java.nio.channels.*;  

public class Program {  

    static public void main( String args[] ) throws Exception {  

        FileInputStream fin = new FileInputStream("c:\\test.txt");  

        // 1. 从FileInputStream获取Channel  

        FileChannel fc = fin.getChannel();            

        // 2. 创建Buffer 

        ByteBuffer buffer = ByteBuffer.allocate(1024);            

        // 3. 将数据从Channel读取到Buffer中 

        fc.read(buffer);  

        buffer.flip();            

        while (buffer.remaining()>0) {  

            byte b = buffer.get();  

            System.out.print(((char)b));  

        }            

        fin.close();  

    }  

}

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

import java.io.*;  

import java.nio.*;  

import java.nio.channels.*;  

public class Program {  

    static private final byte message[] = { 83, 111, 109, 101, 32,  

        98, 121, 116, 101, 115, 46 };  

    static public void main( String args[] ) throws Exception {  

        FileOutputStream fout = new FileOutputStream( "c:\\test.txt" );  

        // 1. 从FileInputStream获取Channel   

        FileChannel fc = fout.getChannel();  

         // 2. 创建Buffer  

        ByteBuffer buffer = ByteBuffer.allocate( 1024 );  

        // 3. 将数据从Channel写入到Buffer中  

        for (int i=0; i<message.length; ++i) {  

            buffer.put( message[i] );  

        }  

        buffer.flip();            

        fc.write(buffer);            

        fout.close();  

    }  

}

Selector

传统的 Server/Client 模式会基于 TPR（Thread per Request）,服务器会为每个客户端请求建立一个线程，由该线程单独负责处理一个客户请求。这种模式带来的一个问题就是线程数量的剧增，大量的线程会增大服务器的开销。大多数的实现为了避免这个问题，都采用了线程池模型，并设置线程池线程的最大数量，这由带来了新的问题，如果线程池中有200个线程，而有200个用户都在进行大文件下载，会导致第201个用户的请求无法及时处理，即便第201个用户只想请求一个几KB大小的页面。

NIO 中非阻塞 I/O 采用了基于 Reactor 模式的工作方式，I/O 调用不会被阻塞，是通过注册 I/O 事件，如可读数据到达，新的套接字连接等发生特定事件时，系统再通知我们。NIO 中实现非阻塞 I/O的核心对象就是 Selector，Selector 就是注册各种 I/O 事件地方，而且当那些事件发生时，就是这个对象告诉我们所发生的事件。

当有读或写等任何注册的事件发生时，可以从 Selector 中获得相应的 SelectionKey，同时从 SelectionKey 中可以找到发生的事件和该事件所发生的具体的 SelectableChannel，以获得客户端发送过来的数据。

转载请并标注: “本文转载自 linkedkeeper.com (文／张松然)”