Java NIO
您目前处于:编程  2015-09-01

在 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 ”  ©著作权归作者所有