Java NIO内存映射---上G大文件处理

港控/mmm° 2022-06-13 06:42 173阅读 0赞

[林炳文Evankaka][Evankaka] 原创作品。转载请注明出处 [http://blog.csdn.net/evankaka][http_blog.csdn.net_evankaka]

摘要：本文主要讲了[Java][]中内存映射的原理及过程，与传统IO进行了对比，最后，用实例说明了结果。

# 一、java中的内存映射IO和内存映射文件是什么？ #

内存映射文件非常特别，它允许Java程序直接从内存中读取文件内容，通过将整个或部分文件映射到内存，由操作系统来处理加载请求和写入文件，应用只需要和内存打交道，这使得IO操作非常快。加载内存映射文件所使用的内存在Java堆区之外。Java编程语言支持内存映射文件，通过java.nio包和MappedByteBuffer 可以从内存直接读写文件。

**内存映射文件  **

内存映射文件，是由一个文件到一块内存的映射。Win32提供了允许应用程序把文件映射到一个进程的函数 (CreateFileMapping)。内存映射文件与虚拟内存有些类似，通过内存映射文件可以保留一个地址空间的区域，同时将物理存储器提交给此区域，内存文件映射的物理存储器来自一个已经存在于磁盘上的文件，而且在对该文件进行操作之前必须首先对文件进行映射。使用内存映射文件处理存储于磁盘上的文件时，将不必再对文件执行I/O操作，使得内存映射文件在处理[大数据][Link 1]量的文件时能起到相当重要的作用。

**内存映射IO**

在传统的文件IO操作中，我们都是调用[操作系统][Link 2]提供的底层标准IO系统调用函数 read()、write() ，此时调用此函数的进程（在JAVA中即java进程）由当前的用户态切换到内核态，然后OS的内核代码负责将相应的文件数据读取到内核的IO缓冲区，然 后再把数据从内核IO缓冲区拷贝到进程的私有地址空间中去，这样便完成了一次IO操作。这么做是为了减少磁盘的IO操作，为了提高性能而考虑的，因为我们的程序访问一般都带有局部性，也就是所 谓的局部性原理，在这里主要是指的空间局部性，即我们访问了文件的某一段数据，那么接下去很可能还会访问接下去的一段数据，由于磁盘IO操作的速度比直接 访问内存慢了好几个数量级，所以OS根据局部性原理会在一次 read()系统调用过程中预读更多的文件数据缓存在内核IO缓冲区中，当继续访问的文件数据在缓冲区中时便直接拷贝数据到进程私有空间，避免了再次的低 效率磁盘IO操作。其过程如下

![20150915155944738][]

内存映射文件和之前说的 标准IO操作最大的不同之处就在于它虽然最终也是要从磁盘读取数据，但是它并不需要将数据读取到OS内核缓冲区，而是直接将进程的用户私有地址空间中的一 部分区域与文件对象建立起映射关系，就好像直接从内存中读、写文件一样，速度当然快了。

![20150915160418594][]

**内存映射的优缺点**

内存映射IO最大的优点可能在于性能，这对于建立高频电子交易系统尤其重要。内存映射文件通常比标准通过正常IO访问文件要快。另一个巨大的优势是内存映 射IO允许加载不能直接访问的潜在巨大文件 。经验表明，内存映射IO在大文件处理方面性能更加优异。尽管它也有不足——增加了页面错误的数目。由于操作系统只将一部分文件加载到内存，如果一个请求 页面没有在内存中，它将导致页面错误。同样它可以被用来在两个进程中共享数据。  
  
**支持内存映射IO的操作系统**  
  
       大多数主流操作系统比如Windows平台，UNIX，Solaris和其他类UNIX操作系统都支持内存映射IO和64位架构，你几乎可以将所有文件映射到内存并通过JAVA编程语言直接访问。  
  
**Java的内存映射IO的要点**  
  
如下为一些你需要了解的java内存映射要点：  
  
java通过java.nio包来支持内存映射IO。  
内存映射文件主要用于性能敏感的应用，例如高频电子交易平台。  
通过使用内存映射IO，你可以将大文件加载到内存。  
内存映射文件可能导致页面请求错误，如果请求页面不在内存中的话。  
映射文件区域的能力取决于于内存寻址的大小。在32位机器中，你不能访问超过4GB或2 ^ 32（以上的文件）。  
内存映射IO比起Java中的IO流要快的多。  
加载文件所使用的内存是Java堆区之外，并驻留共享内存，允许两个不同进程共享文件。  
内存映射文件读写由操作系统完成，所以即使在将内容写入内存后java程序崩溃了，它将仍然会将它写入文件直到操作系统恢复。  
出于性能考虑，推荐使用直接字节缓冲而不是非直接缓冲。  
不要频繁调用MappedByteBuffer.force()方法，这个方法意味着强制操作系统将内存中的内容写入磁盘，所以如果你每次写入内存映射文件都调用force()方法，你将不会体会到使用映射字节缓冲的好处，相反，它(的性能)将类似于磁盘IO的性能。

万一发生了电源故障或主机故障，将会有很小的机率发生内存映射文件没有写入到磁盘，这意味着你可能会丢失关键数据。

# 二、实例代码 #

1、传统IO读取数据,不指定缓冲区大小

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\*  
2.      \* 传统IO读取数据,不指定缓冲区大小 
3.      \* @author linbingwen  
4.      \* @since  2015年9月5日   
5.      \* @param path  
6.      \* @return  
7.      \*/    
8.     **public** **static** **void** readFile1(String path) \{   
9.      **long** start = System.currentTimeMillis();//开始时间  
10.        File file = **new** File(path);    
11.        **if** (file.isFile()) \{    
12.            BufferedReader bufferedReader = **null**;    
13.            FileReader fileReader = **null**;    
14.            **try** \{    
15.                fileReader = **new** FileReader(file);    
16.                bufferedReader = **new** BufferedReader(fileReader);    
17.                String line = bufferedReader.readLine();    
18.                System.out.println("========================== 传统IO读取数据，使用虚拟机堆内存 ==========================");    
19.                **while** (line != **null**) \{ //按行读数据  
20.                    System.out.println(line);    
21.                    line = bufferedReader.readLine();    
22.                \}    
23.            \} **catch** (FileNotFoundException e) \{    
24.                e.printStackTrace();    
25.            \} **catch** (IOException e) \{    
26.                e.printStackTrace();    
27.            \} **finally** \{    
28.             //最后一定要关闭  
29.                **try** \{    
30.                    fileReader.close();    
31.                    bufferedReader.close();    
32.                \} **catch** (IOException e) \{    
33.                    e.printStackTrace();    
34.                \}    
35.                **long** end = System.currentTimeMillis();//结束时间  
36.                System.out.println("传统IO读取数据，不指定缓冲区大小，总共耗时："\+(end - start)+"ms");  
37.            \}    
38.    
39.        \}    
40.    \}

2、传统IO读取数据,指定缓冲区大小

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\*  
2.      \* 传统IO读取数据,指定缓冲区大小 
3.      \* @author linbingwen  
4.      \* @since  2015年9月5日   
5.      \* @param path  
6.      \* @return  
7.      \* @throws FileNotFoundException  
8.      \*/    
9.  **public** **static** **void** readFile2(String path) **throws** FileNotFoundException \{  
10.     **long** start = System.currentTimeMillis();//开始时间  
11.     **int** bufSize = 1024 \* 1024 \* 5;//5M缓冲区  
12.     File fin = **new** File(path); // 文件大小200M  
13.     FileChannel fcin = **new** RandomAccessFile(fin, "r").getChannel();  
14.     ByteBuffer rBuffer = ByteBuffer.allocate(bufSize);                        
15.     String enterStr = "\\n";  
16.     **long** len = 0L;  
17.     **try** \{  
18.         **byte**\[\] bs = **new** **byte**\[bufSize\];  
19.         String tempString = **null**;  
20.         **while** (fcin.read(rBuffer) != -1) \{ //每次读5M到缓冲区  
21.             **int** rSize = rBuffer.position();  
22.             rBuffer.rewind();  
23.             rBuffer.get(bs);//将缓冲区数据读到数组中  
24.             rBuffer.clear();//清除缓冲  
25.             tempString = **new** String(bs, 0, rSize);  
26.             **int** fromIndex = 0;//缓冲区起始  
27.             **int** endIndex = 0;//缓冲区结束  
28.             //按行读缓冲区数据  
29.             **while** ((endIndex = tempString.indexOf(enterStr, fromIndex)) != -1) \{  
30.                 String line = tempString.substring(fromIndex, endIndex);//转换一行            
31.                 System.out.print(line);                    
32.                 fromIndex = endIndex + 1;  
33.             \}  
34.         \}  
35.            **long** end = System.currentTimeMillis();//结束时间  
36.            System.out.println("传统IO读取数据,指定缓冲区大小，总共耗时："\+(end - start)+"ms");  
37.   
38.     \} **catch** (IOException e) \{  
39.         e.printStackTrace();  
40.     \}  
41. \}

3、内存映射读文件

**\[java\]**  [view plain][]   [copy][view plain]

1.  /\*\* 
2.       \* NIO 内存映射读大文件 
3.       \* @author linbingwen 
4.       \* @since  2015年9月15日  
5.       \* @param path 
6.       \*/  
7.      **public** **static** **void** readFile3(String path) \{  
8.          **long** start = System.currentTimeMillis();//开始时间  
9.          **long** fileLength = 0;    
10.         **final** **int** BUFFER\_SIZE = 0x300000;// 3M的缓冲    
11.             File file = **new** File(path);    
12.             fileLength = file.length();    
13.             **try** \{    
14.                 MappedByteBuffer inputBuffer = **new** RandomAccessFile(file, "r").getChannel().map(FileChannel.MapMode.READ\_ONLY, 0, fileLength);// 读取大文件    
15.     
16.                 **byte**\[\] dst = **new** **byte**\[BUFFER\_SIZE\];// 每次读出3M的内容    
17.     
18.                 **for** (**int** offset = 0; offset < fileLength; offset += BUFFER\_SIZE) \{    
19.                     **if** (fileLength - offset >= BUFFER\_SIZE) \{    
20.                         **for** (**int** i = 0; i < BUFFER\_SIZE; i++)    
21.                             dst\[i\] = inputBuffer.get(offset + i);    
22.                     \} **else** \{    
23.                         **for** (**int** i = 0; i < fileLength - offset; i++)    
24.                             dst\[i\] = inputBuffer.get(offset + i);    
25.                     \}    
26.                     // 将得到的3M内容给Scanner，这里的XXX是指Scanner解析的分隔符    
27.                     Scanner scan = **new** Scanner(**new** ByteArrayInputStream(dst)).useDelimiter(" ");    
28.                     **while** (scan.hasNext()) \{    
29.                         // 这里为对读取文本解析的方法    
30.                         System.out.print(scan.next() + " ");    
31.                     \}    
32.                     scan.close();    
33.                 \}    
34.                 System.out.println();  
35.                 **long** end = System.currentTimeMillis();//结束时间  
36.                 System.out.println("NIO 内存映射读大文件，总共耗时："\+(end - start)+"ms");  
37.             \} **catch** (Exception e) \{    
38.                 e.printStackTrace();    
39.             \}    
40.     \}   
41.

# 三、测试对比 #

1、100M文件

文件大小如下：

![20150915185123191][]

调用如下：

**\[java\]**  [view plain][]   [copy][view plain]

1.  **public** **static** **void** main(String args\[\]) \{  
2.      String path = "D:" + File.separator + "CES\_T\_MSM\_LIQ-TRANS-ESP\_20150702\_01.DAT";    
3.      readFile1(path);  
4.      //readFile2(path);  
5.      //readFile3(path);  
6.  \}

（1）传统IO读取数据，不指定缓冲区大小，总共耗时：80264ms

其内存使用如下：

![20150915183439116][]

（2）传统IO读取数据,指定缓冲区大小，总共耗时：80612ms

其内存使用如下：

![20150915183521119][]

（3）NIO 内存映射读大文件，总共耗时：90955ms

其内存使用如下：

![20150915183540275][]

分析发现内存映射并没有比传统IO快多少，甚至还更加慢了，有可能是因为磁盘IO操作多了，反而降低了其效率，内存映射看来还是对大文件比较有好的效果。小文件基本上是没有多大的差别的。

2、1.2G文件

传统IO读取数据，不指定缓冲区大小，总共耗时：1245111ms

NIO 内存映射读大文件，总共耗时：1223877ms（大概20分钟多点）

![20150915183943336][]

参考资料：

http://blog.csdn.net/evankaka/article/details/48464013

[Evankaka]: http://my.csdn.net/?ref=toolbar
[http_blog.csdn.net_evankaka]: http://blog.csdn.net/evankaka
[Java]: http://lib.csdn.net/base/java
[Link 1]: http://lib.csdn.net/base/hadoop
[Link 2]: http://lib.csdn.net/base/operatingsystem
[20150915155944738]: /images/20220613/66695b60b2da4a02a11ca32fdbc2d431.png
[20150915160418594]: /images/20220613/51801c922a66485f853c8440d68eb217.png
[view plain]: http://blog.csdn.net/evankaka/article/details/48464013#
[20150915185123191]: /images/20220613/00d2efe7230e40d09cb9c2a4acf550f1.png
[20150915183439116]: /images/20220613/fb4a1241e88e437188ae2c36c7ad4267.png
[20150915183521119]: /images/20220613/ee392bc3586a49fe9d8473d5917fab09.png
[20150915183540275]: /images/20220613/c13bd2f810ea4d7e8245d99d56afb53e.png
[20150915183943336]: /images/20220613/96df06c990894a0bb388bf3724594825.png