1. Diese Seite verwendet Cookies. Wenn du dich weiterhin auf dieser Seite aufhältst, akzeptierst du unseren Einsatz von Cookies. Weitere Informationen

Schnell große Dateien kopieren mit Java NIO

Dieses Thema im Forum "Java" wurde erstellt von Thomas Darimont, 20. November 2008.

  1. Thomas Darimont

    Thomas Darimont Administrator

    Hallo,

    schaut mal hier:
    Code (Java):
    1.  
    2. /**
    3.  *
    4.  */
    5. package de.tutorials;
    6.  
    7. import java.io.File;
    8. import java.io.FileInputStream;
    9. import java.io.FileOutputStream;
    10. import java.io.IOException;
    11. import java.nio.channels.ByteChannel;
    12. import java.nio.channels.FileChannel;
    13. import java.nio.channels.SocketChannel;
    14. import java.nio.channels.WritableByteChannel;
    15.  
    16. /**
    17.  * @author Tom
    18.  *
    19.  */
    20. public class FastFileCopyExample {
    21.  
    22.     /**
    23.      * @param args
    24.      */
    25.     public static void main(String[] args) {
    26.         copy(file("D:/VMWare/40g xp development/xp-s005.vmdk"),
    27.                 file("c:/temp/xp-s005.vmdk"));
    28.     }
    29.  
    30.     private static File file(String path) {
    31.         return new File(path);
    32.     }
    33.    
    34.     public static void copy(File source, File destination) {
    35.         try {
    36.             FileInputStream fileInputStream = new FileInputStream(source);
    37.             FileOutputStream fileOutputStream = new FileOutputStream(
    38.                     destination);
    39.  
    40.             FileChannel inputChannel = fileInputStream.getChannel();
    41.             FileChannel outputChannel = fileOutputStream.getChannel();
    42.  
    43.             transfer(inputChannel, outputChannel, source.length(), 1024 * 1024 * 32 /* 32 MB */, true,true);
    44.  
    45.             fileInputStream.close();
    46.             fileOutputStream.close();
    47.         } catch (Exception e) {
    48.             e.printStackTrace();
    49.         }
    50.     }
    51.  
    52.     public static void transfer(FileChannel fileChannel,
    53.             ByteChannel byteChannel, long lengthInBytes,
    54.             long chunckSizeInBytes, boolean verbose, boolean fromFile)
    55.             throws IOException {
    56.  
    57.         long overallBytesTransfered = 0L;
    58.         long time = -System.currentTimeMillis();
    59.         while (overallBytesTransfered < lengthInBytes) {
    60.  
    61.             long bytesTransfered = 0L;
    62.  
    63.             if (fromFile) {
    64.                 bytesTransfered = fileChannel.transferTo(0, Math.min(
    65.                         chunckSizeInBytes, lengthInBytes
    66.                                 - overallBytesTransfered), byteChannel);
    67.             } else {
    68.                 bytesTransfered = fileChannel.transferFrom(byteChannel,
    69.                         overallBytesTransfered, Math.min(chunckSizeInBytes,
    70.                                 lengthInBytes - overallBytesTransfered));
    71.             }
    72.  
    73.             overallBytesTransfered += bytesTransfered;
    74.  
    75.             if (verbose) {
    76.                 System.out.printf(
    77.                         "overall bytes transfered: %s progress %s%%\n",
    78.                         overallBytesTransfered, Math
    79.                                 .round(overallBytesTransfered
    80.                                         / ((double) lengthInBytes) * 100.0));
    81.             }
    82.  
    83.         }
    84.         time += System.currentTimeMillis();
    85.  
    86.         if (verbose) {
    87.             System.out.printf("Transfered: %s bytes in: %s s -> %s kbytes/s",
    88.                     overallBytesTransfered, time / 1000,
    89.                     (overallBytesTransfered / 1024.0) / (time / 1000.0));
    90.         }
    91.  
    92.     }
    93. }
    94.  
    Code (Text):
    1.  
    2. overall bytes transfered: 33554432 progress 2%
    3. overall bytes transfered: 67108864 progress 3%
    4. overall bytes transfered: 100663296 progress 5%
    5. overall bytes transfered: 134217728 progress 6%
    6. overall bytes transfered: 167772160 progress 8%
    7. overall bytes transfered: 201326592 progress 9%
    8. overall bytes transfered: 234881024 progress 11%
    9. overall bytes transfered: 268435456 progress 13%
    10. overall bytes transfered: 301989888 progress 14%
    11. overall bytes transfered: 335544320 progress 16%
    12. overall bytes transfered: 369098752 progress 17%
    13. overall bytes transfered: 402653184 progress 19%
    14. overall bytes transfered: 436207616 progress 20%
    15. overall bytes transfered: 469762048 progress 22%
    16. overall bytes transfered: 503316480 progress 23%
    17. overall bytes transfered: 536870912 progress 25%
    18. overall bytes transfered: 570425344 progress 27%
    19. overall bytes transfered: 603979776 progress 28%
    20. overall bytes transfered: 637534208 progress 30%
    21. overall bytes transfered: 671088640 progress 31%
    22. overall bytes transfered: 704643072 progress 33%
    23. overall bytes transfered: 738197504 progress 34%
    24. overall bytes transfered: 771751936 progress 36%
    25. overall bytes transfered: 805306368 progress 38%
    26. overall bytes transfered: 838860800 progress 39%
    27. overall bytes transfered: 872415232 progress 41%
    28. overall bytes transfered: 905969664 progress 42%
    29. overall bytes transfered: 939524096 progress 44%
    30. overall bytes transfered: 973078528 progress 45%
    31. overall bytes transfered: 1006632960 progress 47%
    32. overall bytes transfered: 1040187392 progress 49%
    33. overall bytes transfered: 1073741824 progress 50%
    34. overall bytes transfered: 1107296256 progress 52%
    35. overall bytes transfered: 1140850688 progress 53%
    36. overall bytes transfered: 1174405120 progress 55%
    37. overall bytes transfered: 1207959552 progress 56%
    38. overall bytes transfered: 1241513984 progress 58%
    39. overall bytes transfered: 1275068416 progress 59%
    40. overall bytes transfered: 1308622848 progress 61%
    41. overall bytes transfered: 1342177280 progress 63%
    42. overall bytes transfered: 1375731712 progress 64%
    43. overall bytes transfered: 1409286144 progress 66%
    44. overall bytes transfered: 1442840576 progress 67%
    45. overall bytes transfered: 1476395008 progress 69%
    46. overall bytes transfered: 1509949440 progress 70%
    47. overall bytes transfered: 1543503872 progress 72%
    48. overall bytes transfered: 1577058304 progress 74%
    49. overall bytes transfered: 1610612736 progress 75%
    50. overall bytes transfered: 1644167168 progress 77%
    51. overall bytes transfered: 1677721600 progress 78%
    52. overall bytes transfered: 1711276032 progress 80%
    53. overall bytes transfered: 1744830464 progress 81%
    54. overall bytes transfered: 1778384896 progress 83%
    55. overall bytes transfered: 1811939328 progress 85%
    56. overall bytes transfered: 1845493760 progress 86%
    57. overall bytes transfered: 1879048192 progress 88%
    58. overall bytes transfered: 1912602624 progress 89%
    59. overall bytes transfered: 1946157056 progress 91%
    60. overall bytes transfered: 1979711488 progress 92%
    61. overall bytes transfered: 2013265920 progress 94%
    62. overall bytes transfered: 2046820352 progress 96%
    63. overall bytes transfered: 2080374784 progress 97%
    64. overall bytes transfered: 2113929216 progress 99%
    65. overall bytes transfered: 2143158272 progress 100%
    66. Transfered: 2143158272 bytes in: 33 s -> 62548.280087265775 kbytes/s
    67.  
    Für das kopieren von 2 gb brauch ich damit nur 33 s.

    Gruß Tom
    mccae sagt Danke.
  2. The_S

    The_S Gast

    N bisschen viel Code für die Methode FileChannel.transferTo/transferFrom ;) . Was evtl. in diesem Zusammenhang auch noch interessant ist: http://commons.apache.org/io/
  3. Thomas Darimont

    Thomas Darimont Administrator

    Hallo,

    Was soll denn das heißen? ;-) Wenn man eine Datei häppchenweise via FileChannel transferTo/From transportieren möchte bleibt einem nichts anderes übrig als diesen Code drum herum zu bauen.

    Kannst aber auch gerne mal versuchen eine 2gb datei mit fileChannel.transferTo driekt zu versenden :p
    Vielleicht bekommst du das auch schneller hin ;-)

    Außerdem kann die Transfer Methode nicht nur von einem FileChannel lesen und in einen anderen ByteChannel reinschreiben sondern auch umgekehrt.

    Das "pseudo" logging dient nur zur Verdeutlichung...

    CommonsIO ist mir wohl bekannt ;-) Dort wird in der Klasse FileUtils auch der FileChannel verwendet. Leider
    kann man damit aber nur Dateien kopieren die auch in den Speicher passen...

    Da meine Variante Blockweise kopiert gibts hier keine Größenbeschränkungen.

    Gruß Tom
  4. The_S

    The_S Gast

    Hehe, wollte doch nur ein bisschen stänkern ;) .

    Die IO-Tools sollten nicht als Verbesserung von deinem Code verstanden werden, sondern als Ergänzung. Wer sich mit dem performanten Kopieren von Dateien beschäftigt, der sollte eben evtl. auch mal da einen Blick rein werfen.

    Schönes Wochenende!
  5. takidoso

    takidoso Erfahrenes Mitglied

    Hallo Tom,
    ich habe Deine Routinen nch nicht ausprobiert, aber meine Frage ...ab welcher Java-Version funktioniert Dein Beispiel?

    mit neugierigem Gruß

    Takidoso
  6. Thomas Darimont

    Thomas Darimont Administrator

    Hallo,

    wenn man die System.out.printf calls in println umschreibt sollte das ganze auch unter 1.4 laufen.

    Gruß Tom
  7. ph0e

    ph0e Gast

    Mh nur mal eine Frage, hast du die kopierten Dateien auch mal getestet? Weil wenn ich hab das mal mit zips probiert und war von dem speed direkt beeindruckt, aber die zips sind nur solange valid wie sie kleiner als ein chunk sind.
    Würde meinen aber dem 2. Chunk schreibt der da Bitmüll beim >Kopieren rein, was auch den speed erklären würde :p
  8. Thomas Darimont

    Thomas Darimont Administrator

    Hallo,

    in der alten transfer-Methode gabs einen Bug der hier diskutiert wurde:
    http://www.tutorials.de/forum/java/245134-datei-mittels-tcp-uebertragen.html

    Gefixedte Version:
    Code (Java):
    1.  
    2. package de.tutorials;
    3.  
    4. import java.io.File;
    5. import java.io.FileInputStream;
    6. import java.io.FileOutputStream;
    7. import java.io.IOException;
    8. import java.nio.channels.ByteChannel;
    9. import java.nio.channels.FileChannel;
    10.  
    11. public class FastFileCopyExample {
    12.  
    13.   /**
    14.    * @param args
    15.    */
    16.   public static void main(String[] args) {
    17.     copy(file("c:/foo.zip"), file("c:/foo-2.zip"));
    18.   }
    19.  
    20.  
    21.   private static File file(String path) {
    22.     return new File(path);
    23.   }
    24.  
    25.  
    26.   public static void copy(File source, File destination) {
    27.     try {
    28.       FileInputStream fileInputStream = new FileInputStream(source);
    29.       FileOutputStream fileOutputStream = new FileOutputStream(destination);
    30.  
    31.       FileChannel inputChannel = fileInputStream.getChannel();
    32.       FileChannel outputChannel = fileOutputStream.getChannel();
    33.  
    34.       transfer(inputChannel, outputChannel, source.length(), 1024 * 1024 * 32 /* 32 MB */, true);
    35.  
    36.       fileInputStream.close();
    37.       fileOutputStream.close();
    38.     } catch (Exception e) {
    39.       e.printStackTrace();
    40.     }
    41.   }
    42.  
    43.  
    44.   public static void transfer(FileChannel inputChannel, ByteChannel outputChannel, long lengthInBytes, long chunckSizeInBytes, boolean verbose) throws IOException {
    45.     long overallBytesTransfered = 0L;
    46.     long time = -System.currentTimeMillis();
    47.     while (overallBytesTransfered < lengthInBytes) {
    48.       long bytesToTransfer = Math.min(chunckSizeInBytes, lengthInBytes - overallBytesTransfered);
    49.       long bytesTransfered = inputChannel.transferTo(overallBytesTransfered, bytesToTransfer, outputChannel);
    50.  
    51.       overallBytesTransfered += bytesTransfered;
    52.  
    53.       if (verbose) {
    54.         long percentageOfOverallBytesTransfered = Math.round(overallBytesTransfered / ((double) lengthInBytes) * 100.0);
    55.         System.out.printf("overall bytes transfered: %s progress %s%%\n", overallBytesTransfered, percentageOfOverallBytesTransfered);
    56.       }
    57.  
    58.     }
    59.     time += System.currentTimeMillis();
    60.  
    61.     if (verbose) {
    62.       double kiloBytesPerSecond = (overallBytesTransfered / 1024.0) / (time / 1000.0);
    63.       System.out.printf("Transfered: %s bytes in: %s s -> %s kbytes/s", overallBytesTransfered, time / 1000, kiloBytesPerSecond);
    64.     }
    65.  
    66.   }
    67. }
    68.  
    Gruß Tom
  9. ph0e

    ph0e Gast

    Ah, ich hät ja auch mal meine Gehirn-Augen-Koordination besser benutzen können.
    Danke, ja so läuft die natürlich gut und richtig :D
  10. Anime-Otaku

    Anime-Otaku Erfahrenes Mitglied

    Was ich mich gerade Frage, wie bestimmt man die "richtige" Chunk size? Gibt es da eine Faustformel?
  11. eStudy

    eStudy Gast

    Hallo Leute,

    das sind ja echt gute Tutorials aber wie kann ich denn mittels NIO Dateien übers Netzwerk mittels Channel kopieren? Da hänge ich irgendwie fest.
  12. gorefest

    gorefest Erfahrenes Mitglied

    Lösung 1 : Du könntest mit JSCh einen SSH-Tunnel aufbauen und java-scp machen. Nachteil : Hierzu benötigst Du einen SSH-Server und einen Account auf selbigem
    Lösung 2 : Du kannst mit JCIFS das Zeug auf einen netzwerk-Mountpoint hochladen (Benötigt aber SAMBA, WEBDAV o.ä)
    Lösung 3 : Du schreibst einen RMI-Server der das Zeug annimmt und serialisierst die Chunks dahin (Benötigt einen RMI-Server)

    Grüße
    gore
  13. Coke_

    Coke_ Grünschnabel

    Ersteinmal wollte ich mich für den Thread bedanken, es klappt wirklich 1A und ist wesendlich schneller als die methoden die ich vorher hatte...
    Eine kleine Frage noch, wie kann ich das nun in Verbindung mit einer progress bar bringen? Sodass es noch ein bisschen schöner ausschaut. Ich hab das leider nicht hinbekommen...
  14. Adi_M

    Adi_M Grünschnabel

    Coke_, einen ProgressBar könnt ich dir anbieten. Hab den in die transfer-Methode von Thomas "reingepfropft", da er in dieser Methode alle Parameter, die für einen ProgressMonitor nötig sind, übergibt.
    Was mich auch wiederum gleich zu einer Frage meinerseits, an die Profis, bringt: Dieses "reinstöpseln" eines ProgressMonitors in diese Methode scheint mir ziemlich dirty. Könntet ihr mir da Empfehlungen bzw. Tipps geben wie man das sauber hinkriegt.
    Davon würden Coke(wenn er hier noch aktiv mitliest) u. meine Wenigkeit sehr profitieren.
    Code (Text):
    1.     public static void transfer(FileChannel inputChannel, ByteChannel outputChannel,
    2.         long lengthInBytes, long chunckSizeInBytes, boolean verbose) throws IOException
    3.     {
    4.         progMonitor = new ProgressMonitor(null, "Kopiere " + src.getName(), "Kopiert... ", 0, 100);
    5.         long overallBytesTransfered = 0L;
    6.         while (overallBytesTransfered < lengthInBytes && verbose)
    7.         {
    8.             long bytesToTransfer = Math.min(chunckSizeInBytes, lengthInBytes - overallBytesTransfered);
    9.             long bytesTransfered = inputChannel.transferTo(overallBytesTransfered, bytesToTransfer,
    10.                 outputChannel);
    11.  
    12.             overallBytesTransfered += bytesTransfered;
    13.             double megabyte = overallBytesTransfered / 1048576;
    14.             if (verbose && progMonitor != null)
    15.             {
    16.                 long percentageOfOverallBytesTransfered = Math.round(overallBytesTransfered / ((double) lengthInBytes) * 100.0);
    17.                 progMonitor.setNote("<html>Fortschritt: " + percentageOfOverallBytesTransfered + " %<br>"
    18.                     + "MB übertragen: " + megabyte);
    19.                 progMonitor.setProgress((int) percentageOfOverallBytesTransfered);
    20.                 // createlogfile("overall bytes transfered: " +
    21.                 // overallBytesTransfered +
    22.                 // "\tPercent transferred " + percentageOfOverallBytesTransfered + "%");
    23.             }
    24.         }
    25.         if (progMonitor != null)
    26.         {
    27.             progMonitor.close();
    28.         }
    29.         progMonitor = null;
    30.  
    31.     }
    Danke im Voraus, für eure Empfehlungen bzw. Tipps.
  15. JavaCoffeeDrinker

    JavaCoffeeDrinker Grünschnabel

    Hallo liebe Community,
    ich bin noch ein ziemlicher Java Anfänger und begreife nicht wie man den Code von Adi_M in den von Thomas einbinden kann. Ich bastle gerade an einem Installer und könnte dies daher sehr gut gebrauchen.
    Thx
  16. genodeftest

    genodeftest Erfahrenes Mitglied

    Dann eröffne einen neuen Thread in dem du genau schilderst, was du brauchst. Mit so wenig Informationen kann man nichts anfangen.
  17. schnuffie

    schnuffie Erfahrenes Mitglied

    Für solche Zwecke würde ich einen Listener verwenden, der die Werte immer wieder übergeben bekommt. In dessen wird dann die ProgressBar jedes Mal aktualisiert. Bei Swing z.B. kann man das dann klever asynchron erledigen lassen: SwingUtilities.invokeLater(...)

Diese Seite empfehlen