Performant große Dateien durchsuchen

[osiris86]

Hallo erstmal,

ich habe mehrere große Logdateien die ca. 50 - 500 MB groß werden können, und will diese gerne mit Regex durchsuchen.
Leider ist mir aufgefallen das es bei einer 30MB Datei (ca. 100.000 Zeilen) schon min. 3 Sec. dauert
bis die Datei komplett durchsucht wurde.
Wisst ihr vielleicht eine perfomantere Möglichkeit große Dateien zu durchsuchen?!
Das Problem scheint das einlesen der Zeilen in den Stringbuffer zu sein.

    Scanner sc = null;
    try {
      sc = new Scanner(new File("D:/grosseLogDatei.log"));
    } catch (FileNotFoundException e) {
      System.err.println("File not found" + e.getMessage());
    }
    StringBuffer buff = new StringBuffer();
    while (sc.hasNext()) {
      buff.append(sc.nextLine());
    }
    String regex = ("(?i)" + "(suchtext)");
    Pattern p = Pattern.compile(regex);
    Matcher m = p.matcher(buff);
    while (m.find()) {
      System.out.println(" " + m.group());
    }
    sc.close();

Danke schon mal für eure Antworten

Gruß

 

[SlaterB]

> Das Problem scheint das einlesen der Zeilen in den Stringbuffer zu sein.

prüfe das doch, messe mit System.currentTimeMillis(), wieviel Zeit genau aufs Einlesen und andere Schritte entfällt

1 sec pro 10 MB allein fürs Einlesen hielte ich nicht für so schlecht,
selbst wenn das Programm Zufallsdaten erzeugen würde, wäre mir das allein für die Speicherreservierung + Befüllung recht ordentlich

bisschen schneller geht aber immer irgendwie,
Scanner liest den Text sowieso schon in irgendeine Art Buffer, muss für dein Programm dann mühsam nach Zeilen trennen,
und die Zeilen sammelst du selber wieder in einen Buffer, das klingt unnötig doppelt,
aber hat immerhin einen Effekt, das Aussortieren der Zeilenumbrüche, die musst du sonst im RegEx berücksichtigen
(mit kleinen Test-String von drei Zeilen testen, Pattern.MULIT_LINE spielt da wohl mit, google-Suche)

zum Einlesen jedenfalls alternative FileReader und dort char[] lesen, immer gleich 100.000 Zeichen oder so, die kann man bestimmt auch in den StringBuffer einfügen,

StringBuilder ist minimal moderner und schneller als StringBuffer

das schnellste Lesen bietet vielleich FileChannel, kenne ich aber nicht
Using FileChannel to read text file : FileChannelFileJava Tutorial

 

[KrokoDiehl]

Du liest in dem geposteten Code zuerst die Datei komplett ein, und durchsuchst sie dann komplett nach nach dem RegExp. Wenn du den gesamten Inhalt nicht brauchst, könnte es schon etwas bringen, wenn du eine Zeile liest, hier nach RegExp suchst. Aber das ist natürlich auch eine Frage, wie die Datei inhaltlich aufgebaut ist und schlägt zB dann fehl, wenn der RegExp über mehrere Zeilen geht.

Sprich etwas wie:

while (sc.hasNext()) {
    String line = sc.nextLine();

    myPattern.matcher(line);
    ...

}

 

[fastjack]

Ich vermute mal, bei p.matcher(...) wirds klemmen, wenn das auf nen Riesenstring losgelassen wird, durch geeignete Ausgaben wirst Du genaueres erfahren. Ansonsten würde ich auch einfach zeilenweise, oder besser blockweise (also jeweils 100 Zeilen usw.), prüfen.

 

[osiris86]

Die Zeilen einzelt durchsuchen habe ich auch schon probiert, das dauert sogar noch ein stück länger.
System.currentTimeMillis() habe ich auch schon probiert, es liegt definitiv am einlesen in den StringBuffer, das durchsuchen mit regex, geht ziemlich flott.
Ich werde es mal mit dem FileReader probieren, vielleicht klappt es besser, ich melde mich dann nochmal.

Gruß & Danke für die Antworten

 

[osiris86]

Also mit dem BufferedReader geht es einwandfrei...

try {
	    BufferedReader reader = new BufferedReader(new FileReader(new File(
		    "D:/test.txt")));
	    while (reader.readLine() != null) {
		String line = reader.readLine();
		if (line != null && line.contains("test")) {
		    System.out.println(line);
		}
	    }
	} catch (FileNotFoundException e) {
	    e.printStackTrace();
	} catch (IOException e) {
	    e.printStackTrace();
	}

ich bau jetzt mal das Regex ein und dann sesh ich mal weiter!

Danke für den Tipp

 

[Jay_030]

Je nach Größe der Dateien, Suchaufwand und vorhandener Rechenknechtkraft würde es sich auch lohnen, das Einlesen und Durchsuchen der Daten in Threads aufzuteilen, wenn denn das Einlesen solange dauert. Wenn z.B. die ersten 100 oder 500 Zeichen gelesen sind, kann bereits ein Worker-Thread diese mit einem RegEx durchsuchen. Währenddessen liest dein "Reader-Thread" die nächsten paar hundert Zeichen ein usw usf.

Vorzugsweise mittels ThreadPools, also ExecutorService und Executors zu lösen. Damit du die Arbeitspakete immer auf eine feste Anzahl Threads verteilen kannst, würde sich ein FixedThreadPool gut eignen.

Musst du schauen, ob das dann noch was bringt.

 

[Wildcard]

Wenn du wirklich vor hast den kompletten Inhalt der Datei in den Speicher zu laden, dann mach es zumindest so:

File file = new File("D:/grosseLogDatei.log"):
...
    StringBuilder buff = new StringBuilder(file.length());
    while (sc.hasNext()) {
      buff.append(sc.nextLine());
    }

Wenn du den StringBuilder/Buffer mit einer sinnvollen Größe initialisierst muss das interne Array nicht ständig vergrößert und umkopiert werden.

 

[fastjack]

Oder nutze apache.commons.io. Dort gibt es sehr viele Möglichkeiten im Umgang mit Dateien. Interessant für Dich sind vielleicht die readFile-Methoden der FileUtils-Klasse.