Zip-File entpacken: unterschiedlicher Zeitaufwand bei unterschiedlicher Puffergröße

Endymion

Bekanntes Mitglied
Hi, ich habe ein Programm geschrieben, das zip-Files entpackt. Es hat zum schreiben eine Puffer (Zeile 36). Wenn ich diesen jetzt verändere, also nach oben, oder nach unten, und gleichzeitig auch die Puffergröße des BufferedInputStreams und die des BufferedOutputStreams (Zeile 33/35) auf den gleichen wert setze, habe ich einen viel höheren zeitaufwand, bei einer Puffergröße von 1 etwa den doppelten, bei einer von 81920000 habe ich nach eine viertel abgebrochen und war bei der vierfachen Zeit. Beim Standartpuffer von 8kb (8192 Byte) ist es am schnellsten. Warum ist das so?


Java:
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.Collections;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;

public class unzip {
	public static void main(String[] args) {
		if (args.length != 2) {
			System.out
					.printf("use: java unzip <source path> <destination path>%nprogram canceled%n");
			System.exit(0);
		}
		try {
			System.out.printf("started unzipping %s to %s%n", args[0], args[1]);
			ZipFile src = new ZipFile(args[0]);
			try {
				File dest = new File(args[1]);
				dest.mkdirs();
				for (ZipEntry entry : Collections.list(src.entries())) {
					System.out.printf("writing %s...", entry.getName());
					File f = new File(dest, entry.getName());
					if (entry.isDirectory()) {
						f.mkdirs();
					} else {
						new File(f.getParent()).mkdirs();
						InputStream is = new BufferedInputStream(
								src.getInputStream(entry));
						OutputStream os = new BufferedOutputStream(
								new FileOutputStream(f));
						byte[] buffer = new byte[8192];
						for (int len; (len = is.read(buffer)) != -1;) {
							os.write(buffer, 0, len);
						}
						os.flush();
						is.close();
						os.close();
					}
					System.out.println(" finished");
				}
				System.out.printf("finished unzipping %s to %s%n", args[0],
						args[1]);
			} catch (IOException e) {
				System.out.println(e.getMessage());
				System.out.println("program canceled");
			}

		} catch (IOException e) {
			System.out.println(e.getMessage());
			System.out.println("program canceled");
		}
	}
}
 
Da kann man nur raten... evtl. schreibt das Filesystem die Daten erst auf die Platte, wenn der Puffer entsprechend gefüllt ist. Grössere Puffer füllen sich langsamer und das Schreiben dauert dann auch noch etwas länger. Aber wie gesagt... nur geraten.
Mal was anderes... wieso 2 mal Try-Catch auf IOException, wo doch der Ablauf im Catchblock der selbe ist?
[EDIT]Evtl. liegt's auch an der Clustergrösse des Dateisystems.[/EDIT]
 
Zuletzt bearbeitet von einem Moderator:
Da stand vor 30min noch was unterschiedliches in den Blöcken. Aber der mit größerem Puffer sollte es doch schneller gehen, weil die JVM dann nicht so oft zwischen schreiben und lesen wechseln muss...
 

Zurück
Oben