Java Arbeitsspeicherverbrauch, Heap Space error korrigieren?

[mindjo]

Hallo an Alle!

Ich habe in meinem Programm folgende Fehlermeldung erhalten:

>>
>> OutOfMemoryError: Java heap space" error
>>

An der Stelle im Code wird eine Datei eingelesen, welche ungefaehr 4 Millionen Zeilen hat, was wohl zu viel fuer den Heap ist. Ich muss die Datei jedoch einlesen, um bestimmte zeilen zu extrahieren, also so:

ArrayList<int[]> myLines = new ArrayList<int []>();
BufferedReader read = new BufferedReader(new FileReader(filePath));

String s = "";

while ((s == reader.readLine()) != null) {

if (s.contains("myLine")) {

String []parts = s.split("\t");

int []a = new int[5];

for (int i = 0; i < 5; i++) {

a[i] = Integer.parseInt(s[i]));

}

myLines.add(a);

}


}

1.
Ich weiss sonst nicht, wie ich das Speichereffizient machen kann, weil diese Zeilen ich fuer den weiteren Programmablauf brauche. Hat jemand da Tipps fuer mich?

2.
Ich benutze ArrayList, weil ich nicht vorher weiss, wie viele Zeilen ich speichern muss, gibt es da einen effizienteren weg, weil soweit ich weiss, wird ja immer wieder ein neues Array erstellt bei der Methode .add(), stimmts?

3. Ich benutze als SubArray ja int[], weil ich dachte, wenn ich genau die groesse angebe, die ich im array erwarte, das an Speicher sparrt, ist das richtig oder bringt das doch nicht so viel und es gibt einen besseren weg?

4. Wo kann ich denn generell mir Informationen ueber Speicherverbrauch holen, also jetzt nicht sowas wie String: 8 Bits oder sowas, sondern halt ob beim z.B. einlesen einer Datei die Zeilen auf den Speicher gepackt werde und wie man sowas verbessern kann?

 

[XPrototypeX]

Du kannst die Size des Heapspaces deiner VM hoch setzten. Ich glaube der Befehl dazu hieß: -Xmx512
Wobei die 512 eine Größe im MB Bereich angibt. Anonsten könntest du einen einfachen BufferedInputStream nehmen und das gane auf Byte ebene machen. Vielleicht dich sogar mit Java NIO Beschäftigen (JDK 7). Stichwort MappedByteBuffer. Dieser Buffer wird gar nicht mehr von der VM sondern vom OS direkt verwaltet.

Edit:

String []parts = s.split("\t");
 
int []a = new int[5];
 
for (int i = 0; i < 5; i++) {
 
a[i] = Integer.parseInt(s[i]));
 
}

Was soll dieser Code deiner Meinung nach machen?

 

[mindjo]

Also zu dem Code, die Zeile in der Datei enthaelt 5 zahlen, getrennt von tabs:

23 1 65 9 31

die ich dann ja inn mein ArrayList speichern will, deswegen splitte ich erst an den Tabs und speichere dann jeweils die zzeilen ab :S?


Mit BufferedInputSTream meinst du einfach die mein BufferedReader zu erstetzen mit:

InputStream in = new BufferedInputStream( new FileInputStream(filename) );

weil den Heapspace darf ich nicht hochsetzen, das das programm spaeter auf anderen Systemen laufen muss..

Gibt es denn fuer meinen Fall, wo ich zeilen speicher, etwas effizienteres als Arraylist?

 

[XPrototypeX]

a[i] = Integer.parseInt(s[i]));

Das funktioniet schon syntaktisch nicht.
s ist ein String wenn mich nicht alles täuscht, daher kein Array. Und eine Arraylist verwendet intern auch nicht mehr als Arrays die dann Abhängig vom von der Größe erweitert werden.
Wenn die Ressourcen an deinem System bregrenzt sind, ist es vielleicht auch gar nicht möglich die ganzen Zahlen unter zu brigen?
Java Standard: Primitive Datentypen ? Wikibooks, Sammlung freier Lehr-, Sach- und Fachbücher

Int = 32 bit. 4 mio Zeilen, eine Zeile 5 Zahlen = 32 * 4000000 * 5 = x bit.
Dein System muss also mindestens x bit zu jeder Zeit verfügbar haben.

Wenn du wirklich den letzten bit herausholen willst würde ich eine Sprache wie C nehmen. Die vm alleine braucht schon Ressourcen und hat intern auch noch eine Menge Zeugs das einen overhead erzeugt.

Am besten erklärst du noch einmal was du mit den 5 Zahlen vorhast. Um bessere Tipps geben zu können wären schon ein paar Informationen über das Programm nützlich

 

[mindjo]

Ah ja, und die Fehlermeldung wird fuer diese Zeile ausgegeben:

int a[] = new int[5];

oder macht das keinen Unterschied?


Und die Zahlen benoetige ich, weil diese gewisse Positionen in anderen dateien angebe, also z.B.

1 3 5 3 7

sagen wir mal das erste ist die ID, mit den naechsten Zahlen hole ich mir gewisse Eintraege an Position 3, 5, 3 und 7.


Macht es denn fuer die Laufzeit und Arbeitsspeicher einen Unterschied, wenn man ArrayList benutzt oder Arrays mit definierten Dimensionen?

 

[XPrototypeX]

Nö das ist geht dann schon in den Micro Bereich also eigentlich egal. Aber ich glaube das Design ist bei dir komplett falsch. Wieso ließt du alle Zahlen ein? Reicht es nicht wenn du nur die die du momentan brauchst einließt ? Wenn du z.B die Zahlenreihe einer bestimmten ID brauchst, würde sich eine Datenbank auf jedenfall lohnen. Dort setzt du einfach das select mit der entsprechenden ID an und hast dann deine Zahlenfolge.

Der Code macht so keinen Sinn:

    String []parts = s.split("\t");
     
    int []a = new int[5];
     
    for (int i = 0; i < 5; i++) {
     
    a[i] = Integer.parseInt(s[i]));
     
    }

Richtig wäre wenn wir davon ausgehen das parts ein Array voll mit Zahlen ist:

	/**
	 * Eigentlich würde ich eine Arraylist verwenden, was passiert wenn statt einer 5er Zahlen Reihenfolge eine 6er gefragt ist? 
	 * Du müsstest dann wieder aktiv im Quellcode sachen ändern. 
	 * @param strings
	 * @param dest
	 */
	private void stringsToInt(String [] strings, int[] dest){
		for (int i = 0; i < dest.length; i++) {
			dest[i] = Integer.parseInt(strings[i]);
		}
	}

Er würde crashen, wenn das Array strings größer als dest ist, Buchstaben in strings vorhanden sind und es gibt keine Möglichkeit zu überprüfen ob dest wirklich 5 zahlen beinhaltet (Verstehe mich nicht falsch dort werden wirklich 5 stehen aber wenn z.B nur 4 Zahlen geparst wurden steht im 5. Fach unsinn drinnen.

Aus Spaß könntest du mal versuchen einen ByteBuffer anzulegen. Da dieser direkt vom OS verwaltet wird, besteht die Chance das es funktioniert:

public void readFile(File file) throws Exception {
		FileInputStream fin = null;

		fin = new FileInputStream(file);

		FileChannel fc = fin.getChannel();
		MappedByteBuffer dataBuffer = null;
		
		
		//Lädt das komplette file in den speicher
		dataBuffer = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
fin.close();
}

Noch eine Sache oben wird dein Stream nicht geschlossen. Das umbedingt nachholen

 

[mindjo]

Ok, ja das mit den Moeglichen Fehlereingaben stimmt, ich weiss aber dass der Eintrag immer die Form:

EinBuchstabe Zahl Zahl Zahl Zahl Zahl

haben muss. Ich wuerde in dem Fall, dass es nicht so ist, einfach eine Exception werfen, weil sonst das Programm weiterhin keinen Sinn mehr macht.


Zum ByteBuffer, was soll der mir genau bringen?? Und wie kriege ich jetzt die jeweiligen zeilen wenn ich den Bytebuffer verwende :S

 

[eMmiE]

Hi,
meine Meinung dazu ist, dass ein Heap Space Error auftritt, weil du jedes Mal, wenn du 5 Zahlen einlesen willst einen NEUEN int[] erstellst...

Probier mal, einen anzulegen, der ausserhalb der Schleife steht und den du einfach jedes mal aufs neue benutzt, das dürfte dann funktionieren

Gruß eMmiE

P.S.: Auserdem muss die Line, die du einliest ausser den Zahlen und Buchstaben auch "myLine" enthalten, da deine while-Schleife sonst einfach die Nächste einliest

 

[XPrototypeX]

EinBuchstabe Zahl Zahl Zahl Zahl Zahl

Ist das unique? Kannst du davon ausgehen das diese Kombination nur einmal in deinem File vorkommt? Das wäre eine Interessante frage für das andere Thread das du erstellst hast. So könntest du als schnellere Datenstruktur ein HashSet nehmen.

Zum Thema ByteBuffer.
Der Buffer enthält nur Bytes. Das heißt du agierst hier auf ByteEbene. Der MappedByteBuffer wird vom OS kontrolliert, Java braucht deshalb den Speicherbereich nicht in die eigene VM zu laden, was lese Operation schneller macht.

Buffers haben den Vorteil, das sie einen shared content haben. Das heißt du erstellst ein MutterByteBuffer und jedes der "Kind-Buffer" greift direkt auf die Daten des MutterByteBuffers zu.
Hab mal etwas code aus dem Kopf geschrieben, die Methode um die Ints zu splitten musst du selbst schreiben.
Ist natürlich für Neulinge erst mal sehr verwirrend. Aber wenn du die Anwendung performant haben willst, wirst du da nicht drum herum kommen.

public void readFile(File file) throws Exception {
		FileInputStream fin = null;

		fin = new FileInputStream(file);

		FileChannel fc = fin.getChannel();

		MappedByteBuffer dataBuffer = null;

		// Lädt das komplette file in den speicher

		dataBuffer = fc.map(FileChannel.MapMode.READ_ONLY, 0, fc.size());
	
		//Gibt die länge der Zeile an
		int lengthOfLine = 0, position = 0;
		ByteBuffer buffer = null;
		char lineSeperator = System.getProperty("line.seperator").charAt(0);
		
		while(dataBuffer.hasRemaining()){
			
			char currentChar = (char) (dataBuffer.get() & 0xFF);
			lengthOfLine++;
			if(currentChar == lineSeperator){
				
				buffer = dataBuffer.duplicate();
				position = dataBuffer.position();
				
				//setzt die Anfangs position und das limit des neuen Buffers und erstellt diesen
				//Der buffer hat nun den selben inhalt wie der dataBuffer wenn ich etwas am buffer ändert
				//wird es auch im dataBuffer sichtbar und umgekehrt (ist allerdings readonly)
				buffer.position(position-lengthOfLine);
				buffer.limit(position);
				buffer = buffer.slice();
				
				splitInts(buffer);
				
				lengthOfLine = 0; 
			}
			
			
		}
		
		
		fin.close();
	}

	private void splitInts(ByteBuffer buffer){
		//anzahl bytes
		int size = buffer.remaining();
		
		//hier musst du jetzt code schreiben der deine ints teilt siehe Methoden asIntBuffer 
		//wichtig hierbei ein int sind 4 bytes, leerzeichen werden natürlich auch bytes
		// ich würde die fertig Buffer anschließend in einem HashSet speicher 
	}

 

[mindjo]

Hmmmm, jaaa sieht auf den ersteen Blick etwas kompliziert aus ..aber ich gucke es mir sofort an, falls ich ws nicht verstehe frag ich nochmal nach. Sonst vielen Dank fuer die Hilfe und Muehe

 

[XPrototypeX]

Naja, ist das mit dem Reader schon abgehakt? Das wäre auf jeden Fall Anfänger freundlich. Später wenn es funktioniert, jedoch die Performanz zu schlecht ist, kannst du versuche das ganze mit NIO zu coden.

 

[fastjack]

Hi. Es ist schon richtig, wie Du die Daten liest, nämlich nicht alles auf einmal, sondern zeilenweise. Am Ende musst Du den Stream natürlich auch wieder schließen. Der Speicherverbrauch (ein int ist 4 Bytes groß) ist nach Deinem Algorithmus davon abhängig, wieviel Zeilen "myLine" enthalten, wahrscheinlich sehr viele, oder alle Darum wird deine myLines Liste auch riesig groß. Um das zu vermeiden solltest Du die Daten schrittweise abarbeiten, z.B. in 1000'er Schritten. Dann klappts

        List<int[]> myLines = new ArrayList<int[]>();
        BufferedReader reader = new BufferedReader(new FileReader("/lala/lala.txt"));
        String s;
        while ((s = reader.readLine()) != null) {
            if (s.contains("myLine")) {
                String[] parts = s.split("\t");
                int[] a = new int[5];
                for (int i = 0; i < 5; i++) {
                    a[i] = Integer.parseInt(parts[i]);
                }
                myLines.add(a);

                // do stepwise
                if (myLines.size() % 1000 == 0) {
                    // do here some logic with my lines
                    // ...
                    // and clear later
                    myLines.clear();
                }
            }
        }

 

[mindjo]

Von Java NIO habe ich noch nie was gehoert... das waare dann die optimalste Loesung mit grossen Datensaetzen zu arbeiten oder was??
Dann muss ich mir ein paar brauchbare Tutorials angucken

 

[XPrototypeX]

Fälle in denne man sehr viel Datensätze auf einmal im Speicher haben muss sind wirklich extrem selten. Denkst du wirklich das ist die einzigste Möglichkeit? Ich habe immer noch nicht ganz verstanden was da nachher mit den Arrays gemacht werden soll. Bist du dir Sicher das man nicht Schrittweiße ein paar Datensätze aus dem File ließt dann etwas macht damit und eventuell in ein anderes File zurück schreiben kann?

Aber ja, ich habe schon ein paar Programme geschrieben, die wirklich sehr große Files (über 2GB) in den Speicher laden mussten. NIO war mit abstand das schnellste und gleichzeitig ein speicherschonendes Verfahren.

Edit: Wenn du wirklich NIO verwenden willst, lese dir Tuts über den MappedByteBuffer durch. Das wird imho der sein den du brauchst. Es gibt noch ein ByteBuffer (auch DirectByteBuffer genannt, der wird allerdings direkt von der VM Verwaltet und ist daher nicht native gemappt und so für deinen Zweck nicht zu gebrauchen)

 

[mindjo]

Ja das ist auch was ich mir gerade ueberlegt habe, also nach der Idee von >> fastjack (danke!!), nach einer gewissen Anzahl an Eintraegen versuchen diese Abzuarbeiiten.

Oder wuerde es was bringen, wenn ich die Datei 3 mal einlese (da ich drei verschiedene Faelle habe) und diese drei verschiedenen in drei Dateien packe, welche ich dann getrennt nochmal einlese und dann damit arbeite, oder ist das zu viel Kosten an der Performance?

Das NIO guck ich mir auf jeden Fall an, hoert sich schonmal nach das an, was ich brauchen koennte. Hast du vllt iwo Beispiele, wo ich nachgucken kann wie das funktioniert?

 

[fastjack]

NIO nutzt dir in diesem Fall auch nichts. Du musst die Daten einfach schrittweise bearbeiten und dann die Liste clearen, damit Du wieder Platz für die nächsten Schritte hast.

 

[XPrototypeX]

Das kann ich nicht beurteilen, da ich immer noch nicht weiß was genau gemacht werden soll. Im allgemeinen ist es besser Schritteweiße zu arbeiten, besonders wenn das Zielsystem begrenzte Ressourcen hat. So viel über NIO gibt es glaube ich nicht. Im Zweifel google Fragen. Die Methode die ich gesetern gepostet habe erklärt schon das meiste.

Das ganze macht auch nur Sinn, wenn deine txt File eine bestimmte Spezifikation hat. Also wenn du genau weißt welches Byte für was steht. Sprich eine feste Zeilen länge die nicht übschritten wird.

//buffer enthält genau eine Zeile 
private void splitInts(ByteBuffer buffer){
		IntBuffer intBuffer [] = new IntBuffer [5];
		ByteBuffer tmpBuffer = buffer.duplicate();
		
		//ein Int = 4 Bytes einschließlich Byte 10
		tmpBuffer.position(10);
		tmpBuffer.limit(13);
		tmpBuffer = tmpBuffer.slice();
	
		intBuffer[0] = tmpBuffer.asIntBuffer();
		tmpBuffer.reset();
		//mit intBuffer[1] fortsetzen... 
		
	}

Hier gehe ich davon aus das ein Integer zwischen Byte 10 und Byte 13 ist. Merke ein Byte = ein Zeichen.

 

[eMmiE]

Da mit nem Heap Space Error lag bei einem aktuelleren Programm von mir daran, dass ich zu viele Objekte nicht vom Speicher entfernt habe.

Dazu einfach, wenn ihr das Objkt nicht mehr braucht

System.gc()

laufen lassen oder das Objekt einfach mit

objektInstanz.finalize()

aus dem Speicher enfernen.

Gruß eMmiE

 

[fastjack]

Du musst aber aufpassen, da System.gc() nur eine Empfehlung an die VM darstellt, die GC zu starten. Es muss aber nicht sein, sie dann auch läuft.