java流的性能优化2-内存映射文件

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

这是百度上面的解释，相对来说内存映射文件还是非常重要的，但相对于小型项目来说可能完全用不到。
NIO提供了一种将文件映射到内存的方法进行IO操作，他它比常规基于流的IO快很多，以下是几个流之间的比较：

package com.demo;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.IntBuffer;
import java.nio.channels.FileChannel;

/**
* 把400万条数据输入到文件中并且取出来 对比io和nio的效率
* 当数据量过大的时候采用内存映射文件进行优化处理
*
* */
public class Demo {

public static void main(String[] args) throws IOException {
// TODO Auto-generated method stub
long start = System.currentTimeMillis();
int count = 400_00000;
String path = "e:\\temp_cache_tmp";
String path2 = "e:\\temp_nio.tmp";
String path3 = "e:\\temp_nio_mem.tmp";
IoWrite(path, count);
long end = System.currentTimeMillis();
System.out.println("io写入时间" + (end - start));

start = System.currentTimeMillis();
IoRead(path, count);
end = System.currentTimeMillis();
System.out.println("io读取时间" + (end - start));

start = System.currentTimeMillis();
NioWrite(path2, count);
end = System.currentTimeMillis();
System.out.println("nio写入时间" + (end - start));

start = System.currentTimeMillis();
NioRead(path2, count);
end = System.currentTimeMillis();
System.out.println("nio读取时间" + (end - start));

start = System.currentTimeMillis();
NioMemeryWrite(path3, count);
end = System.currentTimeMillis();
System.out.println("nio内存映射文件写入" + (end - start));

start = System.currentTimeMillis();
NioMemeryRead(path3, count);
end = System.currentTimeMillis();
System.out.println("nio内存映射文件读取" + (end - start));
}
/*
* 内存映射文件 读取
* */
public static void NioMemeryRead(String path, int count)
{
FileChannel fc = null;
try {
fc = new FileInputStream(path).getChannel();
IntBuffer ib = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size()).asIntBuffer();
while(ib.hasRemaining())
{
ib.get();
}
if (fc !=null) {
fc.close();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
//内存映射文件进行写入数据
public static void NioMemeryWrite(String path, int count)
{
FileChannel fc = null;;
try {
fc = new RandomAccessFile(path, "rw").getChannel();
IntBuffer ib = fc.map(FileChannel.MapMode.READ_WRITE, 0, count*4).asIntBuffer();
for (int i = 0; i < count; i++) {
ib.put(i);
}
if (fc !=null) {
fc.close();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
/*
* 普通io进行读取
* */
public static void IoRead(String path, int count) throws IOException {
File file = new File(path);
DataInputStream dis = null;
try {
dis = new DataInputStream(new BufferedInputStream(
new FileInputStream(file)));
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for (int i = 0; i < count; i++) {
dis.readInt();

}
dis.close();
}

/*
* 普通io进行读操作
*/
public static void IoWrite(String path, int count) throws IOException {
File f = new File(path);
if (!f.exists()) {
try {
f.createNewFile();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
DataOutputStream dos = null;
try {
dos = new DataOutputStream(new BufferedOutputStream(
new FileOutputStream(f)));
for (int i = 0; i < count; i++) {
dos.writeInt(i);
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
if (dos != null) {
dos.close();
}
}

public static int byte2int(byte b1, byte b2, byte b3, byte b4) {
return ((b1 & 0xff) << 24) | ((b2 & 0xff) << 16) | ((b3 & 0xff) << 18)
| (b4 & 0xff);
}

public static byte[] int2byte(int res) {
byte[] targets = new byte[4];
targets[3] = (byte) (res & 0xff);
targets[2] = (byte) ((res >> 8) & 0xff);
targets[1] = (byte) ((res >> 16) & 0xff);
targets[0] = (byte) ((res >>> 24) & 0xff);
return targets;
}
/*
* 采用Nio进行读取
*/
public static void NioRead(String path, int count) {
File file = new File(path);
FileInputStream fin = null;
try {
fin = new FileInputStream(file);
FileChannel fc = fin.getChannel();
ByteBuffer byteBuffer = ByteBuffer.allocate(count * 4);
fc.read(byteBuffer);
fc.close();
byteBuffer.flip();
while (byteBuffer.hasRemaining()) {
byte2int(byteBuffer.get(), byteBuffer.get(), byteBuffer.get(),
byteBuffer.get());
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}

/*
* 采用Nio进行写
*/
public static void NioWrite(String path, int count) throws IOException {
File file = new File(path);
FileOutputStream fout = null;
try {
fout = new FileOutputStream(file);
FileChannel fileChannel = fout.getChannel();
ByteBuffer byteBuffer = ByteBuffer.allocate(4 * count);
for (int i = 0; i < count; i++) {
byteBuffer.put(int2byte(i));
}
byteBuffer.flip();
fileChannel.write(byteBuffer);
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
fout.close();
}
}

结果如下



总体来看Nio的读取和写入能力相对很快，在这里我的缓存设置比较大是能够完全读取和写入数据的大小，所以效率非常之快，在实践中可能效率要比这个要低一点，但是总体来说使用NIO的内存映射文件相对比其他方式都要快一个数量级