BufferedReader OutOfMemory umgehen?

[japa]

Hi, ich suche eine Möglichkeit große Datei einlesen zu können.

Mit BufferedReader konnte ich ca. 500.000 Zeilen lesen, aber mehr leider auch nicht, ich habe 1000000 Zeilen, die ich lesen muss.

Ich habe nachgeschaut, dass man seine Memory irgendwie erhöhen kann, ich finde diese Lösung nicht so gut, daher suche ich eine andere Lösung z.B:

Die ersten 1000 Zeilen lesen - verarbeiten

Memory freigeben

Die nächsten 1000 Zeilen fortsetzen lesen - verarbeiten ...

Ich kenn mich leider mit Java nicht sehr gut aus, sowas buffer.ReadLine (lineIndex) wäre echt optimal.

gruß
japa

 

[ARadauer]

Wenn du nicht alle Zeilen im Speicher halten musst, würde ich das einfach nicht machen.

Wenn schon mit dem Parameter -Xmx1024m als start parameter kannst du java mehr speicher geben

 

[japa]

Ich habe die große Datei in 8 kleinere gemacht.
Obwohl ich nach jeder Datei .close() aufrufe, wird es nicht im Speicher bereinigt, sodass ich immer noch OutOfMemory habe.

-Xmx1024m hat zwar geholfen, aber das kann doch keine Lösung sein, wenn ich weniger Speicher hätte (4GB), würde es dann garnichts gehen?

 

[Attila]

die einfachste Lösung:

BufferedReader buffer = null;
try {
    buffer = new BufferedReader(new FileReader("file.txt"));
    String line;
    while ((line = buffer.readLine()) != null) {
        // line verarbeiten
    }
} catch (IOException e){ 
    // ...
}

jede 1000 Zeilen verarbeiten:

BufferedReader buffer = null;
StringBuilder sb = new StringBuilder();
try {
    buffer = new BufferedReader(new FileReader("file.txt"));
    String line;
    int lineCounter = 0;
    while ((line = buffer.readLine()) != null) {
        sb.append(line);
        // sb.append(line+"\n");    // + CRLF
        lineCounter++;
        if (lineCounter > 999){
            // 1000 Zeilen verarbeiten
            verarbeitung(sb);
            lineCounter = 0;
            sb.setLength(0); // buffer freigeben
        }
    }
    if (lineCounter > 0){
        verarbeitung(sb);
    }
} catch (IOException e){ 
    // ...
}


public void verarbeitung(StringBuilder sb){
    // buffer (max. 1000 Zeilen) verarbeiten
}

 

[japa]

  public void buildFromTsvFile(String fileName) throws IOException {

   FileReader fileReader = new FileReader(fileName);
    BufferedReader bufferedReader = new BufferedReader(fileReader);
        int documentId = 0;
    while (true) {
      String line = bufferedReader.readLine();
      if (line == null) { break; }
      String[] words = line.split("\\W+");       
      // System.out.println(Arrays.toString(words));
      for (String word : words) {
        word = word.toLowerCase();
        if (!invertedListsInt.containsKey(word)) {
          invertedListsInt.put(word, new ArrayList<Integer>());
        }
        invertedListsInt.get(word).add(documentId);
      }
      documentId++;
    }
    // Resource wieder freigeben    
    bufferedReader.close();
    this.DocuSize = documentId;
  }

@Attila Danke für deine Mühe, aber der Code wird bei mir auch nicht funktionieren, das Prinzip habe ich verstanden, aber Java gibt dem memory von dem Buffer nicht frei.
Das ist das Hauptproblem.

Der obige Code verarbeitet sogar jede Zeile, aber nach ca. 250 000 Zeilen ist die 256MB Memory voll wegen dem Buffer.

Daher suche ich eine andere Lösung z.B:
- Zeile 1 bis 1000 Lesen dann Buffer aufräumen, Problem ist, dass gelesene Zeilen nicht freigegeben gibt, sodass Memory voll wird.
- oder, Datei i verarbeiten, dann Buffer aufräumen, dann Datei i + 1 usw ... (Problem ist dass buffer.close() nicht funktioniert.
- oder, Buffer nur Teil der Datei einliest und Abschnitten sofort freigeben, so ein Buffer habe ich leider in Java noch nicht gefunden.

 

[Attila]

BufferedReader ist in Ordnung.
Map (invertedListInt) verursacht das Problem:

if (!invertedListsInt.containsKey(word)) {
      invertedListsInt.put(word, new ArrayList<Integer>());
}
// hauptsächlich diese Zeile !!!
invertedListsInt.get(word).add(documentId);

 

[DrZoidberg]

Wenn du 1.000.000 Zeilen hast und jede Zeile im Durchschnitt 10 Wörter enthält, dann macht das 10.000.000 Wörter. Das heisst du erstellst 10.000.000 Integer Objekte. Ein Integer Objekt benötigt ca. 20 Byte. Das sind dann schon mal mindestens 200MB allein für die Integers.
Um den Speicherverbrauch zu reduzieren, könntest du dir z.B. deine eigene ArrayList Klasse schreiben, die primitive ints verwendet anstelle von Integern.
Vielleicht ist es auch gar nicht nötig, die gesamte HashMap im Ram zu haben. Was machst du denn mit invertedListsInt nachdem du dort alle Zahlen eingetragen hast?

 

[Attila]

Als Alternative schlage ich vor:

HashMap<String,String> invertedListsInt = new HashMap<String,String>();
if (!invertedListsInt.containsKey(word)) {
    invertedListsInt.put(word, "");
}
invertedListsInt.put(word,invertedListsInt.get(word)+" "+documentId);

 

[DrZoidberg]

Ich schlage vor du verwendest diese Klasse anstelle von ArrayList.

class IntList {
    private int[] array = new int[10];
    private int size = 0;
    
    private void grow() {
        int[] newArray = new int[(array.length * 3)/2];
        for(int i = 0; i < size; i++) {
            newArray[i] = array[i];
        }
        array = newArray;
    }
    
    public void add(int n) {
        if(size == array.length-1) grow();
        array[size++] = n;
    }
    
    public int get(int i) {
        return array[i];
    }
    
    public int size() {
        return size;
    }
}

 

[japa]

:toll:

Ok Danke, jetzt ist alles geklärt, ich wusste nicht, dass Integer so viele Speicher verbraucht, ich habe gezählt, es kam ca. 42 000 000 Integer Objekte raus -.-

Ich hätte noch eine Nebenfrage, wie kann ich den Speicherverbrauch eines Objekt herausfinden?

Danke noch mal für eure Hilfe.

 

[ARadauer]

du hältst ja die daten im speicher, gib java mehr speicher "Extend java heap space" usw... wozu haben wir rechner mit 8GB aufwärts wenn wir dann der jvm nur 256 mb geben...