Java IO性能测试

webcode

浏览: 5954791 次
性别:
来自: 上海

最近访客更多访客>>

ap950

u012363178

wangyy

ybfjavaeye

博主相关

博客

微博

相册

留言

关于我

文章分类

全部博客 (7533)

社区版块

存档分类

2013-02 ( 78)
2013-01 ( 83)
2012-12 ( 121)
更多存档...

在JDK 1.4版本中，新增加了nio包，目前在于提升IO速度。不过大家都知道，增加了nio包之后，旧的io包其实也进行了重写。就算不显示的使用nio包，也可以明显的感觉到速度的提升。

而且很多人在使用io包的时候，也只是知道装饰一个Buffer的InputStream或者OutputStream，速度会更快。

那么，在这几者之间，速度上到底有差距没？差距有多大？我们将进行一次IO操作的性能测试。

测试的IO操作为，普通的文件读写（不带Buffer），带Buffer的文件读写，使用nio的管道的普通文件读写，使用nio的管道的随机文件读写。

先写一个TestIO测试类。

/**
 * 测试IO的抽象类
 * @author wing
 * @date 2012/7/22
 */
public abstract class TestIO {
    private long start, time;
	
	public void testTime(){
		start = System.nanoTime();
		test();
		time = System.nanoTime() - start;
		System.out.format("%.3f\n", time/1.0e9);
	}
	
	protected abstract void test();
}

用来测试test方法的操作耗时。

然后是各种IO操作的FileIO类。

package org.wing.nio.test;

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.IntBuffer;
import java.nio.channels.FileChannel;
import java.nio.channels.FileChannel.MapMode;

/**
 * IO和NIO文件操作
 * @author wing
 * @date 2012/7/22
 */
public class FileIO {
    private static final int count = 400000;
	private static final int bufferSize = 400000;
 
    /**
     * 不使用Buffer包装的输出流写入文件
     */
    public static void writeIO(String fileName){
    	DataOutputStream mDos = null;
    	try {
			mDos = new DataOutputStream(new FileOutputStream(new File(fileName)));
			for(int i = 0; i < count; i++){
				mDos.writeInt(1);
			}
		} catch (FileNotFoundException e) {
			System.out.println("File Not Found:" + e.toString());
		} catch (IOException e) {
			System.out.println("IO Exception:" + e.toString());
		}finally{
		   if(mDos != null){
			try {
				mDos.close();
			} catch (IOException e) {
				System.out.println("Stream Close Exception:" + e.toString());
			}
		   }
		}
    }
    
    /**
     * 不使用Buffer包装输入流读入文件
     */ 
    public static void readIO(String fileName){
    	DataInputStream mDis = null;
    	try {
			mDis = new DataInputStream(new FileInputStream(new File(fileName)));
			for(int i = 0; i < count; i++){
				mDis.readInt();
			}
		} catch (FileNotFoundException e) {
			System.out.println("File Not Found:" + e.toString());
		} catch (IOException e) {
			System.out.println("IO Exception:" + e.toString());
		}finally{
		   if(mDis != null){
			try {
				mDis.close();
			} catch (IOException e) {
				System.out.println("Stream Close Exception:" + e.toString());
			}
		   }
		}
    }
    
    /**
     * 使用Buffer包装的输出流写入文件
     */
    public static void writeIOWithBuffer(String fileName){
    	DataOutputStream mDos = null;
    	try {
			mDos = new DataOutputStream(new BufferedOutputStream(new FileOutputStream(new File(fileName))));
			for(int i = 0; i < count; i++){
				mDos.writeInt(1);
			}
		} catch (FileNotFoundException e) {
			System.out.println("File Not Found:" + e.toString());
		} catch (IOException e) {
			System.out.println("IO Exception:" + e.toString());
		}finally{
		   if(mDos != null){
			try {
				mDos.close();
			} catch (IOException e) {
				System.out.println("Stream Close Exception:" + e.toString());
			}
		   }
		}
    }
    
    /**
     * 使用Buffer包装输入流读入文件
     */ 
    public static void readIOWithBuffer(String fileName){
    	DataInputStream mDis = null;
    	try {
			mDis = new DataInputStream(new BufferedInputStream(new FileInputStream(new File(fileName))));
			for(int i = 0; i < count; i++){
				mDis.readInt();
			}
		} catch (FileNotFoundException e) {
			System.out.println("File Not Found:" + e.toString());
		} catch (IOException e) {
			System.out.println("IO Exception:" + e.toString());
		}finally{
		   if(mDis != null){
			try {
				mDis.close();
			} catch (IOException e) {
				System.out.println("Stream Close Exception:" + e.toString());
			}
		   }
		}
    }
    
    
    /**
     * 使用NIO管道来进行数据写入
     */
    public static void writeNIO(String fileName){
    	FileChannel mFc = null;
    	try {
			mFc = new FileOutputStream(new File(fileName)).getChannel();
			IntBuffer mBuffer = IntBuffer.allocate(bufferSize);
			for(int i = 0; i < count; i++){
				mBuffer.put(1);
			}
		} catch (FileNotFoundException e) {
			System.out.println("File Not Found:" + e.toString());
		}finally{
		   if(mFc != null){
			try {
				mFc.close();
			} catch (IOException e) {
				System.out.println("Channel Close Exception:" + e.toString());
			}
		   }
		}
    }
    
    /**
     * 使用NIO管道来进行数据读取
     */ 
    public static void readNIO(String fileName){
    	FileChannel mFc = null;
    	try {
    		mFc = new FileInputStream(new File(fileName)).getChannel();
    		IntBuffer mBuffer = IntBuffer.allocate(bufferSize);
			for(int i = 0; i < count; i++){
				mBuffer.get();
			}		
		} catch (FileNotFoundException e) {
			System.out.println("File Not Found:" + e.toString());
		}finally{
		   if(mFc != null){
			try {
				mFc.close();
			} catch (IOException e) {
				System.out.println("Channel Close Exception:" + e.toString());
			}
		   }
		}
    }
    
    /**
     * 使用NIO管道来进行数据写入
     */
    public static void writeNIOWithRan(String fileName){
    	FileChannel mFc = null;
    	try {
			mFc = new RandomAccessFile(fileName, "rw").getChannel();
			IntBuffer mBuffer = mFc.map(MapMode.READ_WRITE, 0, 4 * bufferSize).asIntBuffer();
			for(int i = 0; i < count; i++){
				mBuffer.put(1);
			}
		} catch (FileNotFoundException e) {
			System.out.println("File Not Found:" + e.toString());
		} catch (IOException e) {
			System.out.println("IO Exception:" + e.toString());
		}finally{
		   if(mFc != null){
			try {
				mFc.close();
			} catch (IOException e) {
				System.out.println("Channel Close Exception:" + e.toString());
			}
		   }
		}
    }
    
    /**
     * 使用NIO管道来进行数据读取
     */ 
    public static void readNIOWithRan(String fileName){
    	FileChannel mFc = null;
    	try {
			mFc = new RandomAccessFile(fileName, "rw").getChannel();
			IntBuffer mBuffer = mFc.map(MapMode.READ_WRITE, 0, 4 * bufferSize).asIntBuffer();
			for(int i = 0; i < count; i++){
				mBuffer.get();
			}		
		} catch (FileNotFoundException e) {
			System.out.println("File Not Found:" + e.toString());
		} catch (IOException e) {
			System.out.println("IO Exception:" + e.toString());
		}finally{
		   if(mFc != null){
			try {
				mFc.close();
			} catch (IOException e) {
				System.out.println("Channel Close Exception:" + e.toString());
			}
		   }
		}
    }  
}

大家可以看到，上面有各种IO的操作。操作次数是读写int类型400000次。

然后是我们的主类。

package org.wing.nio.test;

public class MainClass {

	public static void main(String[] args) {
		final String fileName = "test";
		TestIO[] testList = new TestIO[] { 
		   new TestIO() {

			@Override
			protected void test() {
				FileIO.writeIO(fileName);
			}
		}, new TestIO() {

			@Override
			protected void test() {
				FileIO.readIO(fileName);
			}
		}, new TestIO() {

			@Override
			protected void test() {
				FileIO.writeIOWithBuffer(fileName);
			}
		}, new TestIO() {

			@Override
			protected void test() {
				FileIO.readIOWithBuffer(fileName);
			}
		}, new TestIO() {

			@Override
			protected void test() {
				FileIO.writeNIO(fileName);
			}
		}, new TestIO() {

			@Override
			protected void test() {
				FileIO.readNIO(fileName);
			}
		},

		new TestIO() {

			@Override
			protected void test() {
				FileIO.writeNIOWithRan(fileName);

			}
		}, new TestIO() {

			@Override
			protected void test() {
				FileIO.readNIOWithRan(fileName);

			}
		},

		};
		
		for(TestIO testIO : testList){
			testIO.testTime();
		}

	}

}

新建了一个TestIO类的数组，分别重写test方法，使用自己的IO操作。然后循环执行TestIO的testTime方法。

运行程序，看看结果。

大家可以看到，在不使用Buffer装饰的IO操作中，进行400000次的int写操作耗时5.764秒，读操作3.301秒。而使用Buffer装饰的IO操作读0.021秒，写0.020秒。但是直接使用nio的管道进行普通文件和随机读写文件的IO操作，耗时更小，写操作仅0.010秒，读操作仅0.006秒。

在第一次测试中，大家可以很明显的看出来，使用Buffer装饰的IO操作已经远远的超过了不使用Buffer装饰的IO操作的速度。而在400000次操作中与nio包的管道读写速度相差无几。

那么，io包跟nio包的IO读写速度就真的差不多么？

我们进行下一轮的测试。

注释掉，不使用Buffer装饰的TestIO类的创建，因为我们要增加IO操作次数了，不使用Buffer装饰的IO操作将会极为耗时。

我们将IO操作次数改为4000000次。

运行查看结果。