Java NIO

转自: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 的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
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() 方法能够把所有的状态变化设置为初始化时的值。

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
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 从文件中读取数据的例子

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
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向文件中写入数据的例子:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
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 (文/张松然)”

此条目发表在java分类目录,贴了标签。将固定链接加入收藏夹。

发表评论

电子邮件地址不会被公开。 必填项已用*标注