1.深入分析_NIO性能分析

首先还是看一个用3中方式copy文件的测试Demo

分别是：普通Stream文件copy，BuffferedStream进行Copy 和Channel(nio)进行文件Copy的代码和性能测试报告：

package com.ctyun.stream;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.channels.FileChannel;
/**
 * 
 * @Description    文件效率copy测试
 * @author         zhanghw@chinatelecom.com.cn
 * @since          2015年9月11日
 * @version        V1.0
 */
public class FileCopyEfficientTest {
    
    //普通io流copy
    public static void commonCopy(String source, String dest){
        FileInputStream in = null;
        FileOutputStream out = null;
        try {
            in = new FileInputStream(new File(source));
            out = new FileOutputStream(new File(dest));
            
            byte[] b = new byte[2048];
            while(in.read(b) != -1  ){
                out.write(b);
            }
            out.flush();
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(in != null){
                    in.close();
                }
                if(out != null){
                    out.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                in = null;
                out =null;
                e.printStackTrace();
            }
        }
    }
    
    //Streambuffer进行copy
    public static void bufferCopy(String source, String dest){
        FileInputStream in = null;
        FileOutputStream out = null;
        BufferedInputStream bufferedIn = null;
        BufferedOutputStream bufferedOut = null;
        
        try {
            in = new FileInputStream(new File(source));
            out = new FileOutputStream(new File(dest));
            
            bufferedIn = new BufferedInputStream(in);
            bufferedOut = new BufferedOutputStream(out);
            
            byte[] b = new byte[2048];
            while(bufferedIn.read(b) != -1  ){
                bufferedOut.write(b);
            }
            bufferedOut.flush();
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(in != null){
                    in.close();
                }
                if(out != null){
                    out.close();
                }
                if(bufferedIn != null){
                    bufferedIn.close();
                }
                if(bufferedOut != null){
                    bufferedOut.close();
                }
            } catch (IOException e) {
                // TODO Auto-generated catch block
                in = null;
                out =null;
                bufferedIn = null;
                bufferedOut = null;
                e.printStackTrace();
            }
        }
    }
    
    //用Channel进行copy
    public static void channelCopy(String source, String dest){
        FileInputStream in = null;
        FileOutputStream out = null;
        FileChannel channelIn = null;
        FileChannel channelOut = null;
        
        try {
            in = new FileInputStream(new File(source));
            out = new FileOutputStream(new File(dest));
            channelIn = in.getChannel();
            channelOut = out.getChannel();
            
            channelIn.transferTo(0, channelIn.size(), channelOut);
            
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            try {
                if(in != null){
                    in.close();
                }
                if(out != null){
                    out.close();
                }
                if(channelIn != null){
                    channelIn.close();
                }
                if(channelOut != null){
                    channelOut.close();
                }
                
            } catch (IOException e) {
                // TODO Auto-generated catch block
                in = null;
                out =null;
                channelIn = null;
                channelOut = null;
                e.printStackTrace();
            }
        }
        
    }
    
    //测试因为会线程原因，造成时间不正确
    /*public static void main(String[] args) {
        String source = "d:/test.txt";
        String dest1 = "d:/temp/test1.txt";
        String dest2 = "d:/temp/test2.txt";
        String dest3 = "d:/temp/test3.txt";
        
        long l1 = System.currentTimeMillis();
        commonCopy(source, dest1);
        long l2 = System.currentTimeMillis();
        System.out.println("普通Stream Copy用时："+(l2-l1));
        
        bufferCopy(source, dest2);
        long l3 = System.currentTimeMillis();
        System.out.println("buffer Stream Copy用时："+(l3-l2));
        
        channelCopy(source, dest3);
        long l4 = System.currentTimeMillis();
        System.out.println("channel Stream Copy用时："+(l4-l3));
        
    }*/
    
    public static void main(String[] args) {
        String source = "d:/test.txt";
        String dest = "d:/temp/test1.txt";
        
        long l1 = System.currentTimeMillis();
//        commonCopy(source, dest);
        bufferCopy(source, dest);
//        channelCopy(source, dest);
        long l2 = System.currentTimeMillis();
        System.out.println("Copy用时："+(l2-l1));
        
    }

}

 性能测试结果及结论：

测试1：不同文件大小测试时间（在同一main函数中进行测试）

大小	普通Copy(毫秒)	BufferCopy(毫秒)	ChannelCopy(毫秒)	文件类型
1m	56	44	72	文本
128m	2095	1132	437	文本
512m	9215	6710	10444	文本
1g	19989	49358	44809	文本
2g	69266	63989	58310	文本

 

结论：通过观察发现此次测试结果之间差异非常大，并且笔者在观察文件copy时，并没有按照正常顺序进行copy，所以（猜测）可能是在同一main方法中因为线程资源不均衡问题，造成测试结果差异较大，不准确（copy文件之间存在干扰）。

为证实以上结论继续如下测试：

---

测试2：在同一main函数中进行测试

1024M多次测试结果

测试次数	大小	普通Copy(毫秒)	BufferCopy(毫秒)	ChannelCopy(毫秒)	文件类型
1	1g	17365	34371	27906	文本
2	1g	39903	35203	19079	文本
3	1g	43865	36720	28984	文本

--------------------------------------

结论:每次性能差异很大，原因可能是(猜测)：在同一个main方法中由于文件流操作时线程获取cup资源的时间不同造成（copy文件之间存在干扰），

为了保证测试的准确性，修改测试为没法方法在main方法中单独测试。

---

单独测试，在一个个main方法运行时，保证只有一个copy方法运行（最终测试方案，正确）（copy文件之间相互独立，不存在干扰）

大小	普通Copy(毫秒)	BufferCopy(毫秒)	ChannelCopy(毫秒)	文件类型
1m	62	16	31	文本
128m	1953	907	422	文本
512m	8126	3422	1141	文本
1g	86944	87572	17703	文本
2g	66079	55298	17219	文本

 

测试次数	大小	普通Copy(毫秒)	BufferCopy(毫秒)	ChannelCopy(毫秒)	文件类型
1	1g	15281	8937	5860	文本
2	1g	15485	7203	5703	文本
3	1g	16068	6828	5422	文本

 

结论：在通常情况下，nio的性能>buffered性能>普通Stream的性能，但是在小文件的时候Buffered性能会比nio好