Java 復制大文件方式（nio2 FileChannel 拷貝文件能力測試）

目前為止，我們已經學習了很多 Java 拷貝文件的方式，除了 FileChannel 提供的方法外，還包括使用 Files.copy() 或使用字節數組的緩沖/非緩沖流。那個才是最好的選擇呢？這個問題很難回答，因為答案基於很多因素。本文將目光集中到一個因素，那就是速度，因為拷貝任務 越快將會提高效率，在有些情況下，這是成功的關鍵。因此，本文將使用一個應用程序來比較下面這些拷貝方式的具體時間：

• FileChannel 和非直接模式的 ByteBuffer
• FileChannel 和直接模式的 ByteBuffer
• FileChannel.transferTo()
• FileChannel.transferFrom()
• FileChannel.map()
• 使用字節數組和緩沖流
• 使用字節數組和非緩沖流
• File.copy()（Path 到 Path，InputStream 到 Path 和 Path 到 OutputStream）

應用程序基於下面的條件：

• 拷貝文件類型 MP4 視頻（文件名為 Rafa Best Shots.mp4，所在目錄為 C:\rafaelnadal\tournaments\2009\videos）
• 文件大小：58.3MB
• 測試的緩沖區大小：4KB, 16KB, 32KB, 64KB, 128KB, 256KB, and 1024KB
• 機器配置：Mobile AMD Sempron Processor 3400 + 1.80 GHz, 1.00GB RAM, 32-bit
  OS, Windows 7 Ultimate
• 測量類型：使用 System.nanoTime() 方法
• 連續運行三次后再獲取時間；前三次運行將會被忽略。開始運行的時間總會比后面運行的時間要長一些。

下面將列出完整的應用程序：

import java.nio.MappedByteBuffer;
import java.io.OutputStream;
import java.io.InputStream;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.channels.FileChannel;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.util.EnumSet;
import static java.nio.file.LinkOption.NOFOLLOW_LINKS;
 
public class Main {
 
 public static void deleteCopied(Path path){
         
  try {
      Files.deleteIfExists(path);
  } catch (IOException ex) {
    System.err.println(ex);
  }
         
 }
     
 public static void main(String[] args) {
 
 final Path copy_from = Paths.get("C:/rafaelnadal/tournaments/2009/videos/
                                                                        Rafa Best Shots.mp4");
 final Path copy_to = Paths.get("C:/Rafa Best Shots.mp4");
 long startTime, elapsedTime;
 int bufferSizeKB = 4; //also tested for 16, 32, 64, 128, 256 and 1024
 int bufferSize = bufferSizeKB * 1024;
 
 deleteCopied(copy_to);
 
 //FileChannel and non-direct buffer
 System.out.println("Using FileChannel and non-direct buffer ...");
 try (FileChannel fileChannel_from = (FileChannel.open(copy_from,  
                      EnumSet.of(StandardOpenOption.READ)));
      FileChannel fileChannel_to = (FileChannel.open(copy_to,  
                      EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)))) {            
 
      startTime = System.nanoTime();
             
      // Allocate a non-direct ByteBuffer
      ByteBuffer bytebuffer = ByteBuffer.allocate(bufferSize);
 
      // Read data from file into ByteBuffer
      int bytesCount;
      while ((bytesCount = fileChannel_from.read(bytebuffer)) > 0) {
       //flip the buffer which set the limit to current position, and position to 0              
       bytebuffer.flip();
       //write data from ByteBuffer to file
       fileChannel_to.write(bytebuffer);
       //for the next read
       bytebuffer.clear();
      }
       
      elapsedTime = System.nanoTime() - startTime;
      System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");
 } catch (IOException ex) {
   System.err.println(ex);
 }
 
 deleteCopied(copy_to);
 
 //FileChannel and direct buffer
 System.out.println("Using FileChannel and direct buffer ...");
 try (FileChannel fileChannel_from = (FileChannel.open(copy_from,  
                      EnumSet.of(StandardOpenOption.READ)));
      FileChannel fileChannel_to = (FileChannel.open(copy_to,  
                      EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)))) {            
 
      startTime = System.nanoTime();
             
      // Allocate a direct ByteBuffer
      ByteBuffer bytebuffer = ByteBuffer.allocateDirect(bufferSize);
 
      // Read data from file into ByteBuffer
      int bytesCount;
      while ((bytesCount = fileChannel_from.read(bytebuffer)) > 0) {
       //flip the buffer which set the limit to current position, and position to 0              
       bytebuffer.flip();
       //write data from ByteBuffer to file
       fileChannel_to.write(bytebuffer);
       //for the next read
       bytebuffer.clear();
      }
       
      elapsedTime = System.nanoTime() - startTime;
      System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");
 } catch (IOException ex) {
   System.err.println(ex);
 }
 
 deleteCopied(copy_to);
 
 //FileChannel.transferTo()
 System.out.println("Using FileChannel.transferTo method ...");
 try (FileChannel fileChannel_from = (FileChannel.open(copy_from,  
                      EnumSet.of(StandardOpenOption.READ)));
      FileChannel fileChannel_to = (FileChannel.open(copy_to,  
                      EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)))) {
 
      startTime = System.nanoTime();
 
      fileChannel_from.transferTo(0L, fileChannel_from.size(), fileChannel_to);
 
      elapsedTime = System.nanoTime() - startTime;
      System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");
 } catch (IOException ex) {
   System.err.println(ex);
 }
 
 deleteCopied(copy_to);
         
 //FileChannel.transferFrom()
 System.out.println("Using FileChannel.transferFrom method ...");
 try (FileChannel fileChannel_from = (FileChannel.open(copy_from,   
                      EnumSet.of(StandardOpenOption.READ)));
      FileChannel fileChannel_to = (FileChannel.open(copy_to,  
                      EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)))) {
 
      startTime = System.nanoTime();
 
      fileChannel_to.transferFrom(fileChannel_from, 0L, (int) fileChannel_from.size());
 
      elapsedTime = System.nanoTime() - startTime;
      System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");
 } catch (IOException ex) {
   System.err.println(ex);
 }
 
 deleteCopied(copy_to);         
         
 //FileChannel.map
 System.out.println("Using FileChannel.map method ...");
 try (FileChannel fileChannel_from = (FileChannel.open(copy_from,  
                      EnumSet.of(StandardOpenOption.READ)));
      FileChannel fileChannel_to = (FileChannel.open(copy_to,  
                      EnumSet.of(StandardOpenOption.CREATE_NEW, StandardOpenOption.WRITE)))) {
                       
      startTime = System.nanoTime();
      MappedByteBuffer buffer = fileChannel_from.map(FileChannel.MapMode.READ_ONLY,  
                                                                  0, fileChannel_from.size());
                         
      fileChannel_to.write(buffer);
      buffer.clear();
 
      elapsedTime = System.nanoTime() - startTime;
      System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");
} catch (IOException ex) {
  System.err.println(ex);
}
         
deleteCopied(copy_to);       
         
//Buffered Stream I/O  
System.out.println("Using buffered streams and byte array ...");  
File inFileStr = copy_from.toFile();
File outFileStr = copy_to.toFile();
try (BufferedInputStream in = new BufferedInputStream(new FileInputStream(inFileStr));
     BufferedOutputStream out = new BufferedOutputStream(new FileOutputStream(outFileStr))) {
 
     startTime = System.nanoTime();
 
     byte[] byteArray = new byte[bufferSize];
     int bytesCount;
     while ((bytesCount = in.read(byteArray)) != -1) {
             out.write(byteArray, 0, bytesCount);
     }
 
     elapsedTime = System.nanoTime() - startTime;
     System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");
} catch (IOException ex) {
  System.err.println(ex);
}
 
deleteCopied(copy_to);
 
System.out.println("Using un-buffered streams and byte array ...");  
try (FileInputStream in = new FileInputStream(inFileStr);
     FileOutputStream out = new FileOutputStream(outFileStr)) {
 
     startTime = System.nanoTime();
 
     byte[] byteArray = new byte[bufferSize];
     int bytesCount;
     while ((bytesCount = in.read(byteArray)) != -1) {
             out.write(byteArray, 0, bytesCount);
     }
 
     elapsedTime = System.nanoTime() - startTime;
     System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");
} catch (IOException ex) {
  System.err.println(ex);
}
 
deleteCopied(copy_to);
 
System.out.println("Using Files.copy (Path to Path) method ...");
try {
    startTime = System.nanoTime();
 
    Files.copy(copy_from, copy_to, NOFOLLOW_LINKS);
 
    elapsedTime = System.nanoTime() - startTime;
    System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");
} catch (IOException e) {
  System.err.println(e);
}
 
deleteCopied(copy_to);
 
System.out.println("Using Files.copy (InputStream to Path) ...");
try (InputStream is = new FileInputStream(copy_from.toFile())) {
 
    startTime = System.nanoTime();
 
    Files.copy(is, copy_to);
 
    elapsedTime = System.nanoTime() - startTime;
    System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");
} catch (IOException e) {
  System.err.println(e);
}
 
deleteCopied(copy_to);
 
System.out.println("Using Files.copy (Path to OutputStream) ...");
try (OutputStream os = new FileOutputStream(copy_to.toFile())) {
 
     startTime = System.nanoTime();
 
     Files.copy(copy_from, os);
 
     elapsedTime = System.nanoTime() - startTime;
     System.out.println("Elapsed Time is " + (elapsedTime / 1000000000.0) + " seconds");
 } catch (IOException e) {
   System.err.println(e);
 }
 }
} 

 

輸出結果排序比較復雜，其中包含了很多數據。下面我將主要的對比用圖形的方式展示出來。圖形中 Y 坐標表示消耗的時間（單位：秒），X 坐標表示緩沖的大小（或運行次數，跳過了前三次運行）。

FileChannel 和非直接模式 Buffer vs. FileChannel 和直接模式 Buffer

從下圖看來，如果緩存小於 256KB，那么非直接模式的 Buffer 快一點，而緩存大於 256KB 后，直接模式的 Buffer 快一點：

FileChannel.transferTo() vs. FileChannel.transferFrom() vs. FileChannel.map()

從下圖看來，FileChannel.transferTo() 和 FileChannel.transferFrom 運行七次的速度都差不多，而 FileChannel.map 的速度就要差很多：

三種 Files.copy() 方法

從下圖看來，最快的是 Path 到 Path，其次是 Path 到 OutputStream，最慢的是 InputStream 到 Path：

FileChannel 和非直接模式 Buffer vs. FileChannel.transferTo() vs. Path 到 Path

最后，我們將前面最快的三種方式綜合起來比較。從比較的結果來看，似乎 Path 到 Path 是最快的解決方案：