NIO中的内存映射文件使用对效率提高的验证

 对比较大的而不能放入内存的文件进行I/O操作时，如果使用NIO中的内存映射文件对性能效率和速度的提高是非常显著的。首先需要获取文件的通道，然后调用通道的map(FileChannel.MapMode mode,long position,long size)函数将文件从position位置开始的长度为size的内容映射到内存中。具体的效率比较代码示例如下：

 

Java代码  

1. import java.io.BufferedInputStream;  
2. import java.io.BufferedOutputStream;  
3. import java.io.DataInputStream;  
4. import java.io.DataOutputStream;  
5. import java.io.FileInputStream;  
6. import java.io.FileOutputStream;  
7. import java.io.IOException;  
8. import java.io.RandomAccessFile;  
9. import java.nio.IntBuffer;  
10. import java.nio.channels.FileChannel;  
11.   
12. //测试代码是借用thingking in java中的  
13. public class MappedIO {  
14.       
15.     //先声明需要写入的文件的内容的大小  
16.     private static final int NUMOFINT=4000000;  
17.     private static final int NUMOFOUT=2000000;  
18.       
19.     //测试类，用来测试使用普通的I/O操作和使用内存文件映射时速度的差别  
20.     abstract static class Tester{  
21.         private String name;  
22.         public Tester(String name){  
23.             this.name=name;  
24.         }  
25.           
26.         public void runTest(){  
27.             System.out.println("使用"+name+"所消耗的时间:");  
28.             try{  
29.             //以毫微秒为单位获取测试函数开始前的时间  
30.             long begin=System.nanoTime();  
31.               
32.             test();  
33.             //将测试函数结束后的系统的时间减去开始之前的时间获取  
34.             double duration=System.nanoTime()-begin;  
35.             //PrintStream中的使用指定格式字符串和参数将格式化字符串写入此输出流中的方法  
36.             System.out.format("%.2f\n", duration/1.0e9);  
37.             }catch(IOException e){  
38.                 e.printStackTrace();  
39.             }  
40.         }  
41.           
42.         //具体的测试函数中其实不仅有对文件进行读取或写入的时间，还包括消耗的各种初始化I/O对象的时间，而且内存映射文件的初始化对象消耗更要比普通的操作大  
43.         public abstract void test() throws IOException;  
44.     }  
45.       
46.     private static Tester[] tests={  
47.         //先使用普通的stream write，并且还是用了Buffered缓冲  
48.         new Tester("stream write"){  
49.             public void test()throws IOException{  
50.                 DataOutputStream dos=new DataOutputStream(new BufferedOutputStream(new FileOutputStream("baolei.txt")));   
51.                 for(int i=0;i<NUMOFINT;i++){  
52.                     dos.writeInt(i);  
53.                 }  
54.                 dos.close();  
55.             }  
56.         },  
57.         //使用内存映射文件方式写入文件时的测试内部类  
58.         new Tester("mapped write"){  
59.             public void test() throws IOException{  
60.                 //利用RandomAccessFile初始化文件获取通道  
61.                 FileChannel fc=new RandomAccessFile("baolei.txt","rw").getChannel();  
62.                 //利用IntBuffer基本类型视图缓冲器来修改底层的ByteBuffer，实际上ByteBuffer是将数据移进移出通道的唯一方式  
63.                 IntBuffer ib=fc.map(FileChannel.MapMode.READ_WRITE, 0,fc.size()).asIntBuffer();  
64.                 for(int i=0;i<NUMOFINT;i++){  
65.                     ib.put(i);  
66.                 }  
67.                   
68.                 fc.close();  
69.             }  
70.         },  
71.           
72.         //下面的两个测试方法是测试read文件时的速度，基本和上面的两个一样  
73.         new Tester("stream read"){  
74.             public void test()throws IOException{  
75.                 DataInputStream dis=new DataInputStream(new BufferedInputStream(new FileInputStream("baolei.txt")));  
76.                   
77.                 for(int i=0;i<NUMOFOUT;i++){  
78.                     dis.readInt();  
79.                 }  
80.                 dis.close();  
81.             }  
82.         },  
83.         new Tester("mapped read"){  
84.             public void test() throws IOException{  
85.                 FileChannel fc=new RandomAccessFile("baolei.txt","rw").getChannel();  
86.                 IntBuffer ib=fc.map(FileChannel.MapMode.READ_WRITE, 0, fc.size()).asIntBuffer();  
87.                 while(ib.hasRemaining()){  
88.                     ib.get();  
89.                 }  
90.                   
91.                 fc.close();  
92.             }  
93.         }  
94.   
95.     };  
96.       
97.     public static void main(String[] args){  
98.         for(Tester test:tests){  
99.             test.runTest();  
100.         }  
101.     }  
102.   
103. }  

 

   可以看到运行后的结果如下：

           使用stream write所消耗的时间:
           0.92
          使用mapped write所消耗的时间:
           0.12 
          使用stream read所消耗的时间:
           0.50
         使用mapped read所消耗的时间:
           0.06
    效率确实大幅度提高啊。