转：http://jackyin5918.iteye.com/blog/2024231
package io;
import java.io.File;
import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.MappedByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
/**
* Java NIO(内存映射文件) 与 传统IO 读取 性能测试
*
* 读取 RandomAccessFile 类读写测试及其性能优化(一)
* (链接 http://jackyin5918.iteye.com/blog/2022888 )中
* GenerateIntArray 生成的并保存到文件的数据.
* 测试时读取1千万个整型构成的二进制文件38.1M
*
* 由测试结果分析可知:
*
* readData(f) -- 普通IO方式读取
* readDataNIO(f) -- NIO Channel,Buffer方式读取
* readDataNIO_D(f) -- NIO中Buffer使用 直接方式分配空间(allocateDirect)
* readDataMap_M(f) -- 多线程中使用 内存映射文件
* readDataMap(f) -- 单线程中使用内存映射文件读取
*
* NIO方式使用直接分配Buffer空间方式读取性能最好,甚至超过了内存映射文件
* (可能是文件还不够大,如果文件达到1000M以上应该是内存映射文件性能最好).
*
* 普通NIO方式 耗时 是NIO_D方式的2倍.
*
* 传统IO方式读取文件,耗时 是NIO的 上百倍.
*
* 内存映射文件,在文件较大(大小达到几十M时)可以显著提升性能.
* 多线程中使用内存映射文件 没有 提高性能.
----------------------测试结果---------
count = 1000, size = 10000
正在读取数据,请稍后...
readData(f) 读取数据成功, 耗时:411326
正在读取数据,请稍后...
readDataNIO_D(f) 读取数据成功, 耗时:4161
正在读取数据,请稍后...
readDataNIO(f) 读取数据成功, 耗时:10645
正在读取数据,请稍后...
readDataMap_M(f) 读取数据成功, 耗时:6682
正在读取数据,请稍后...
readDataMap 读取数据成功, 耗时:4841
*/
public class GetTheMiddle
{
private int count = 10; // 数组的个数,
private int size = 1000; // 每个数组的元素个数
private int[][] dataArr;
public GetTheMiddle()
{
dataArr = new int[count][size];
}
public GetTheMiddle(int count, int size)
{
this.count = count;
this.size = size;
this.dataArr = new int[count][size];
}
public int[][] getDataArr()
{
return dataArr;
}
public int[][] readData(File f)
{
try
{
RandomAccessFile rf = new RandomAccessFile(f, "r");
for (int i = 0; i < count; i++)
{
for (int j = 0; j < size; j++)
{
dataArr[i][j] = rf.readInt();
}
}
rf.close();
}
catch (Exception e)
{
e.printStackTrace();
}
return dataArr;
}
public int[][] readDataNIO(File f)
{
try
{
RandomAccessFile rf = new RandomAccessFile(f, "r");
FileChannel fc = rf.getChannel();
ByteBuffer buffer = ByteBuffer.allocate(size * 4);
for (int i = 0; i < count; i++)
{
fc.read(buffer);
buffer.rewind();
for (int j = 0; j < size; j++)
{
dataArr[i][j] = buffer.getInt();
}
buffer.rewind();
}
rf.close();
}
catch (Exception e)
{
e.printStackTrace();
}
return dataArr;
}
public int[][] readDataNIO_D(File f)
{
try
{
RandomAccessFile rf = new RandomAccessFile(f, "r");
FileChannel fc = rf.getChannel();
ByteBuffer buffer = ByteBuffer.allocateDirect(size * 4);
for (int i = 0; i < count; i++)
{
fc.read(buffer);
buffer.rewind();
for (int j = 0; j < size; j++)
{
dataArr[i][j] = buffer.getInt();
}
buffer.rewind();
}
rf.close();
}
catch (Exception e)
{
e.printStackTrace();
}
return dataArr;
}
public int[][] readDataMap(File f)
{
try
{
RandomAccessFile rf = new RandomAccessFile(f, "r");
FileChannel fc = rf.getChannel();
int mapSize = size * 4;
for (int i = 0; i < count; i++)
{
int position = i * size * 4;
MappedByteBuffer mBuffer = fc.map(MapMode.READ_ONLY,position,mapSize);
for (int j = 0; j < size; j++)
{
dataArr[i][j] = mBuffer.getInt();
}
}
rf.close();
}
catch (Exception e)
{
e.printStackTrace();
}
return dataArr;
}
class ReadDataTask implements Runnable
{
private File f;
private int dataIndex;
public ReadDataTask(File f,int dataIndex)
{
this.f = f;
this.dataIndex = dataIndex;
}
@Override
public void run()
{
try
{
RandomAccessFile rf = new RandomAccessFile(f, "r");
FileChannel fc = rf.getChannel();
int mapSize = size * 4;
int position = dataIndex * size * 4;
MappedByteBuffer mBuffer = fc.map(MapMode.READ_ONLY,position,mapSize);
for (int j = 0; j < size; j++)
{
dataArr[dataIndex][j] = mBuffer.getInt();
}
rf.close();
}
catch (Exception e)
{
e.printStackTrace();
}
}
}
public int[][] readDataMap_M(File f)
{
try
{
ExecutorService exec = Executors.newCachedThreadPool();
for(int i=0;i<count;i++)
{
exec.execute(new ReadDataTask(f,i));
}
exec.shutdown();
while(true)
{
if(exec.isTerminated()) break;
}
}
catch (Exception e)
{
e.printStackTrace();
}
return dataArr;
}
public static void main(String[] args)
{
int count = 1000;
int size = 10000;
boolean bPrintData = false; // 是否打印生成的数组,当数据量大是不打印,只在小数据量时打印以便测试
boolean bRefreshData = true; //是否重新生成数据,第一次测试时生成数据后,改成false不必重新生成数据
System.out.printf("count = %d, size = %d \n\n", count, size);
GetTheMiddle gm = new GetTheMiddle(count,size);
GenerateIntArray generator = new GenerateIntArray(count, size);
File f;
try
{
f = new File("D:\\D\\test_data.dat");
if(bRefreshData)
{
generator.refreshDataArr();
generator.writeData2File_B(f);
}
System.out.println("正在读取数据,请稍后...");
long startTmie = System.nanoTime();
gm.readData(f);
long totalTime = (System.nanoTime() - startTmie)/ 100000;
System.out.println("readData(f) 读取数据成功, 耗时:" + totalTime);
System.out.println();
System.out.println("正在读取数据,请稍后...");
startTmie = System.nanoTime();
gm.readDataNIO_D(f);
totalTime = (System.nanoTime() - startTmie)/ 100000;
System.out.println("readDataNIO_D(f) 读取数据成功, 耗时:" + totalTime);
System.out.println();
System.out.println("正在读取数据,请稍后...");
startTmie = System.nanoTime();
gm.readDataNIO(f);
totalTime = (System.nanoTime() - startTmie)/ 100000;
System.out.println("readDataNIO(f) 读取数据成功, 耗时:" + totalTime);
System.out.println();
System.out.println("正在读取数据,请稍后...");
startTmie = System.nanoTime();
gm.readDataMap_M(f);
totalTime = (System.nanoTime() - startTmie)/ 100000;
System.out.println("readDataMap_M(f) 读取数据成功, 耗时:" + totalTime);
System.out.println();
System.out.println("正在读取数据,请稍后...");
startTmie = System.nanoTime();
gm.readDataMap(f);
totalTime = (System.nanoTime() - startTmie)/ 100000;
System.out.println("readDataMap 读取数据成功, 耗时:" + totalTime);
System.out.println();
}
catch (Exception e)
{
e.printStackTrace();
}
if(bPrintData)
{
System.out.println("generator中生成的数据...");
int[][] intArr = generator.getDataArr();
for (int i = 0; i < count; i++)
{
for (int j = 0; j < size; j++)
{
System.out.printf("%1$3d", intArr[i][j]);
}
System.out.println();
}
System.out.println("读取出来的数组...");
intArr = gm.getDataArr();
for (int i = 0; i < count; i++)
{
for (int j = 0; j < size; j++)
{
System.out.printf("%1$-5s", intArr[i][j]);
}
System.out.println();
}
}
}
}