你的位置:首页 > Java教程

[Java教程]NIO提升系统性能


  • 前言

  在软件系统中,I/O的速度要比内存的速度慢很多,因此I/O经常会称为系统的瓶颈。所有,提高I/O速度,对于提升系统的整体性能有很大的作用。

  在java标准的I/O中,是基于流的I/O的实现,即InputStream和OutPutStream,这种基于流的实现以字节为基本单元,很容易实现各种过滤器。

  NIO和new I/O的简称,在java1.4纳入JDK中,具有以下特征:

  1、为所有的原始类型提供(buffer)缓存支持;

  2、使用Charset作为字符集编码解码解决方案;

  3、增加了通道(Channel)对象,作为新的原始I/O抽象;

  4、支持锁和内存访问文件的文件访问接口;

  5、提供了基于Selector的异步网络I/O;

  NIO是基于块(Block)的,它以块为基本单位处理数据。在NIO中,最重要的两个组件是buffer缓冲和channel通道。缓冲是一块连续的内存区域,是NIO读写数据的中转站。通道表示缓冲数据的源头或目的地,它用于向缓冲读取或写入数据,是访问缓冲的接口。通道和缓冲的关系如图:

  

  • NIO中的Buffer类和Channel

  JDK为每一种java原生类型都提供了一种Buffer,除了ByteBuffer外,其他每一种Buffer都具有完全一样的操作,除了操作类型不一样以外。ByteBuffer可以用于绝大多数标准I/O操作的接口。

  在NIO中和Buffer配合使用的还有Channel。Channel是一个双向通道,既可以读也可以写。有点类似Stream,但是Stream是单向的。应用程序不能直接对Channel进行读写操作,而必须通过Buffer来进行。

  下面以一个文件复制为例,简单介绍NIO的Buffer和Channel的用法,代码如下:

 1 public class NioCopyFileTest { 2   public static void main(String[] args) throws Exception { 3     NioCopyFileTest.copy("test.txt", "test2.txt"); 4   } 5    6   public static void copy(String resource,String destination) throws Exception{ 7     FileInputStream fis = new FileInputStream(resource);  8     FileOutputStream fos = new FileOutputStream(destination); 9     10     FileChannel inputFileChannel = fis.getChannel();//读文件通道11     FileChannel outputFileChannel = fos.getChannel();//写文件通道12     ByteBuffer byteBuffer = ByteBuffer.allocate(1024);//读写数据缓冲13     while(true){14       byteBuffer.clear();15       int length = inputFileChannel.read(byteBuffer);//读取数据16       if(length == -1){17         break;//读取完毕18       }19       byteBuffer.flip();20       outputFileChannel.write(byteBuffer);//写入数据21     }22     inputFileChannel.close();23     outputFileChannel.close();24   }25 }

  代码中注释写的很详细了,输入流和输出流都对应一个Channel通道,将数据通过读文件channel读取到缓冲中,然后再通过写文件channel写入到缓冲中。这样就完成了文件复制。注意:缓冲在文件传输中起到的作用十分大,可以缓解内存和硬盘之间的性能差异,提升系统性能。

  • Buffer的基本原理

  Buffer有三个重要的参数:位置(position)、容量(capactiy)和上限(limit)。这三个参数的含义如下图:

  下面例子很好的解释了Buffer的工作原理:

 1      ByteBuffer buffer = ByteBuffer.allocate(15);//设置缓冲区大小为15 2     System.out.println("position:"+buffer.position()+"limit:"+buffer.limit()+"capacity"+buffer.capacity()); 3     for (int i = 0; i < 10; i++) { 4       buffer.put((byte) i); 5     } 6     System.out.println("position:"+buffer.position()+"limit:"+buffer.limit()+"capacity"+buffer.capacity()); 7     buffer.flip();//重置position 8     for (int i = 0; i < 5; i++) { 9       System.out.println(buffer.get());10     }11     System.out.println("position:"+buffer.position()+"limit:"+buffer.limit()+"capacity"+buffer.capacity());12     buffer.flip();13     System.out.println("position:"+buffer.position()+"limit:"+buffer.limit()+"capacity"+buffer.capacity());

  以上代码,先分配了15个字节大小的缓冲区。在初始阶段,position为0,capacity为15,limit为15。注意,position是从0开始的,所以索引为15的位置实际上是不存在的。

  接着往缓冲区放入10个元素,position始终指向下一个即将放入的位置,所有position为10,capacity和limit依然为15。

  进行flip()操作,会重置position的位置,并且将limit设置到当前position的位置,这时Buffer从写模式进入读模式,这样就可以防止读操作读取到没有进行操作的位置。所有此时,position为0,limit为10,capacity为15。

  接着进行五次读操作,读操作会设置position的位置,所以,position为5,limit为10,capacity为15。

  在进行一次flip()操作,此时可想而知position为0,limit为5,capacity为15。

  • Buffer的相关操作

  Buffer是NIO中最核心的对象,它的一系列的操作和使用也需要重点掌握,这里简单概括一下,也可以参考相关API查看。

  1、Buffer的创建:

  buffer的常见有两种方式,使用静态方法allocate()从堆中分配缓冲区,或者从一个既有数组中创建缓冲区。

1 ByteBuffer buffer = ByteBuffer.allocate(1024);//从堆中分配2 byte[] arrays = new byte[1024];//从既有数组中创建3 ByteBuffer buffer2 = ByteBuffer.wrap(arrays);

  2、重置或清空缓冲区:

  buffer还提供了一些用于重置和清空缓冲区的方法:rewind(),clear(),flip()。它们的作用如下:

  3、读写缓冲区:

  对Buffer对象进行读写操作是Buffer最重要的操作,buffer提供了许多读写操作的缓冲区。具体参考API。

  4、标志缓冲区

  标志(mark)缓冲区是一个在数据处理时很有用的功能,它就像书签一样,可以在数据处理中随时记录当前位置,然后再任意时刻回到这个位置,从而简化或加快数据处理的流程。相关函数为:mark()和reset()。mark()用于记录当前位置,reset()用于恢复到mark标记的位置。

  代码如下:

 1 ByteBuffer buffer = ByteBuffer.allocate(15);//设置缓冲区大小为15 2     for (int i = 0; i < 10; i++) { 3       buffer.put((byte) i); 4     } 5     buffer.flip();//重置position 6     for (int i = 0; i < buffer.limit(); i++) { 7       System.out.print(buffer.get()); 8       if(i==4){ 9         buffer.mark();10         System.out.print("mark at"+i);11       }12     }13     System.out.println();14     buffer.reset();15     while(buffer.hasRemaining()){16       System.out.print(buffer.get());17 }

  输出结果:

1 01234mark at4567892 56789

  5、复制缓冲区

  复制缓冲区是以原缓冲区为基础,生成一个完全一样的缓冲区。方法为:duplicate()。这个函数对于处理复杂的Buffer数据很有好处。因为新生成的缓冲区和元缓冲区共享相同的内存数据。并且,任意一方的改动都是互相可见的,但是两者又各自维护者自己的position、limit和capacity。这大大增加了程序的灵活性,为多方同时处理数据提供了可能。

  代码如下:

 1     ByteBuffer buffer = ByteBuffer.allocate(15);//设置缓冲区大小为15 2     for (int i = 0; i < 10; i++) { 3       buffer.put((byte) i); 4     } 5     ByteBuffer buffer2 = buffer.duplicate();//复制当前缓冲区 6     System.out.println("after buffer duplicate"); 7     System.out.println(buffer); 8     System.out.println(buffer2); 9     buffer2.flip();10     System.out.println("after buffer2 flip");11     System.out.println(buffer);12     System.out.println(buffer2);13     buffer2.put((byte)100);14     System.out.println("after buffer2 put");15     System.out.println(buffer.get(0));16     System.out.println(buffer2.get(0));       

  输出结果如下:

1 after buffer duplicate2 java.nio.HeapByteBuffer[pos=10 lim=15 cap=15]3 java.nio.HeapByteBuffer[pos=10 lim=15 cap=15]4 after buffer2 flip5 java.nio.HeapByteBuffer[pos=10 lim=15 cap=15]6 java.nio.HeapByteBuffer[pos=0 lim=10 cap=15]7 after buffer2 put8 1009 100

  6、缓冲区分片

  缓冲区分片使用slice()方法,它将现有的缓冲区创建新的子缓冲区,子缓冲区和父缓冲区共享数据,子缓冲区具有完整的缓冲区模型结构。当处理一个buffer的一个片段时,可以使用一个slice()方法取得一个子缓冲区,然后就像处理普通缓冲区一样处理这个子缓冲区,而无需考虑边界问题,这样有助于系统模块化。 

 1     ByteBuffer buffer = ByteBuffer.allocate(15);//设置缓冲区大小为15 2     for (int i = 0; i < 10; i++) { 3       buffer.put((byte) i); 4     } 5     buffer.position(2); 6     buffer.limit(6); 7     ByteBuffer subBuffer = buffer.slice();//复制缓冲区 8     for (int i = 0; i < subBuffer.limit(); i++) { 9       byte b = subBuffer.get(i);10       b=(byte) (b*10);11       subBuffer.put(i, b);12     }13     buffer.limit(buffer.capacity());14     buffer.position(0);15     for (int i = 0; i < buffer.limit(); i++) {16       System.out.print(buffer.get(i)+" ");17     }

  输出结果: 

1 0 1 20 30 40 50 6 7 8 9 0 0 0 0 0 

  7、只读缓冲区

  可以使用缓冲区对象的asReadOnlyBuffer()方法得到一个与当前缓冲区一致的,并且共享内存数据的只读缓冲区,只读缓冲区对于数据安全非常有用。使用只读缓冲区可以保证数据不被修改,同时,只读缓冲区和原始缓冲区是共享内存块的,因此,对于原始缓冲区的修改,只读缓冲区也是可见的。

  代码如下:

 1      ByteBuffer buffer = ByteBuffer.allocate(15);//设置缓冲区大小为15 2     for (int i = 0; i < 10; i++) { 3       buffer.put((byte) i); 4     } 5     ByteBuffer readBuffer = buffer.asReadOnlyBuffer(); 6     for (int i = 0; i < readBuffer.limit(); i++) { 7       System.out.print(readBuffer.get(i)+" "); 8     } 9     System.out.println();10     buffer.put(2, (byte)20);11     for (int i = 0; i < readBuffer.limit(); i++) {12       System.out.print(readBuffer.get(i)+" ");13     }

  结果:

1 0 1 2 3 4 5 6 7 8 9 0 0 0 0 0 2 0 1 20 3 4 5 6 7 8 9 0 0 0 0 0 

  由此可见,只读缓冲区并不是原始缓冲区在某一时刻的快照,而是和原始缓冲区共享内存数据的。当修改只读缓冲区时,会报ReadOnlyBufferException异常。

  8、文件映射到内存:

  NIO提供了一种将文件映射到内存的方法进行I/O操作,它可以比常规的基于流的I/O快很多。这个操作主要是由FileChannel.map()方法实现的。

  使用文件映射的方式,将文本文件通过FileChannel映射到内存中。然后在内存中读取文件内容。还可以修改Buffer,将实际数据写到对应的硬盘中。

1      RandomAccessFile raf = new RandomAccessFile("D:\\test.txt", "rw");2     FileChannel fc = raf.getChannel();3     MappedByteBuffer mbf = fc.map(MapMode.READ_WRITE, 0, raf.length());//将文件映射到内存4     while(mbf.hasRemaining()){5       System.out.println(mbf.get());6     }7     mbf.put(0,(byte)98);//修改文件8     raf.close();

  9、处理结构化数据

  NIO还提供了处理结构化数据的方法,称为散射和聚集。散射是将一组数据读入到一组buffer中,聚集是将数据写入到一组buffer中。聚集和散射的基本使用方法和对单个buffer操作的使用方法类似。这一组缓冲区类似于一个大的缓冲区。

  散射/聚集IO对处理结构化数据非常有用。例如,对于一个具有固定格式的文件的读写,在已知文件具体结构的情况下,可以构造若干个符合文件结构的buffer,使得各个buffer的大小恰好符合文件各段结构的大小。

  例如,将"姓名:张三,年龄:18",通过聚集写创建该文件,然后再通过散射都来解析。

 1 ByteBuffer nameBuffer = ByteBuffer.wrap("姓名:张三,".getBytes("utf-8")); 2     ByteBuffer ageBuffer = ByteBuffer.wrap("年龄:18".getBytes("utf-8")); 3     int nameLength = nameBuffer.limit(); 4     int ageLength = ageBuffer.limit(); 5     ByteBuffer[] bufs = new ByteBuffer[]{nameBuffer,ageBuffer}; 6     File file = new File("D:\\name.txt"); 7     if(!file.exists()){ 8       file.createNewFile(); 9     }10     FileOutputStream fos = new FileOutputStream(file);11     FileChannel channel = fos.getChannel();12     channel.write(bufs);13     channel.close();14     15     ByteBuffer nameBuffer2 = ByteBuffer.allocate(nameLength);16     ByteBuffer ageBuffer2 = ByteBuffer.allocate(ageLength);17     ByteBuffer[] bufs2 = new ByteBuffer[]{nameBuffer2,ageBuffer2};18     FileInputStream fis = new FileInputStream("D:\\name.txt");19     FileChannel channel2 = fis.getChannel();20     channel2.read(bufs2);21     String name = new String(bufs2[0].array(),"utf-8");22     String age = new String(bufs2[1].array(),"utf-8");23     24     System.out.println(name+age);

  通过和通道的配合使用,可以简化Buffer对于结构化数据处理的难度。

  注意,ByteBuffer是将文件一次性读入内存再做处理,而Stream方式则是边读取文件边处理数据,这也是两者性能差异的主要原因。

  • 直接内存访问

  NIO的Buffer还提供了一个可以直接访问系统物理内存的类--DirectBuffer。普通的ByteBuffer依然在JVM堆上分配空间,其最大内存,受最大堆的限制。而DirecBuffer直接分配在物理内存中,并不占用堆空间。创建DirectBuffer的方法是:ByteBuffer.allocateDirect(capacity)。

  在对普通的ByteBuffer的访问,系统总会使用一个"内核缓冲区"进行间接操作。而ByteBuffer所处的位置,就相当于这个"内核缓冲区"。因此,DirecBuffer是一种更加接近底层的操作。

  DirectBuffer的访问速度远高于ByteBuffer,但是其创建和销毁所消耗的时间却远大于ByteBuffer。在需要频繁创建和销毁Buffer的场合,显然不适合DirectBuffer的使用,但是如果能将DirectBuffer进行复用,那么在读写频繁的场合下,它完全可以大幅度改善系统性能。