Frage zu Speicherverbrauch

[Schumi]

Hallo, ich habe eine Frage zum Speicherverbrauch. Und zwar frage ich mich, ob es bei den unteren 3 Beispielen Unterschiede gibt und wenn ja, welche Lösung am besten ist.

1. Es gibt eine feste Array, die in der Klasse initialisiert wird und dann wir häufig eine Methode benutzt, die die Array manipuliert:

someClass{
	static int [] array = new int [100000];

	main{
		for(i=0;i<somethingBig;i++){call method}
	}
	method(){
		for(int i=0;i<array.length;i++){array[i]=i;}
	}
}

2. Es gibt eine feste Array, die bei jedem Methodenaufruf initialisiert wird.

someClass{
	static int [] array;

	main{
		for(i=0;i<somethingBig;i++){call method}
	}
	method(){
		array = new int [100000];
		for(int i=0;i<array.length;i++){array[i]=i;}
	}
}

3. Die Array wird bei jedem Methodenaufruf angelegt und initialisiert:

someClass{
	main{
		for(i=0;i<somethingBig;i++){call method}
	}
	method(){
		int[] array = new int [100000];
		for(int i=0;i<array.length;i++){array[i]=i;}
	}
}

Vielen Dank!

 

[Ilja]

hängt davon ab, was für ein array das ist und in welchem kontext er verwendet wird

poate mal den code oder erkläre, was das ganze machen soll

 

[Mag1c]

Hi,

also Variante eins ist auf jeden Fall erstmal die effizienteste. Hier wird genau einmal das Array angelegt und das wars. Auch der GC sitzt ganz entspannt in der Ecke

bei 2 und 3 wird jedesmal ein neues Array angelegt. Das kostet Zeit. Das alte Array wird verworfen, hier muß also der GC ran. Das kostet noch mehr Zeit.

Also ohne das konkrete Problem zu kennen, würde ich Variante 1 bevorzugen. Mach aber das static weg, falls ist nicht zwingend sein muß.

Gruß
Mag1c

 

[bygones]

ich behaupte mal bei Methode 3 fliegt dir irgendwann eine OutOfMemory Exception rum, da du immer wieder einen so grossen array intialisierst. Methode 2 find ich unsinnig - warum immer wieder den gleichen array neu initialisieren.....

 

[Schumi]

Erstmal danke für die schnellen Antworten. Konkret geht es um einen eigene Klasse, die Graphen repräsentiert. Diese benutzt wiederum Klassen für Knoten und Kanten, wobei die Kanten wiederum hauptsächlich aus 2 Knotzen bestehen.

public class DirectedGraph {
	private Node[] nodes;
	private Arc[] arcs;
	private boolean flag;
}

public class Node {
	private int id;
	
	private List<Arc> preds; //Eingehende Bögen
	private List<Arc> descs; //Ausgehende Bögen
	private boolean flag;
}

public class Arc{
	
	private char id;
	private Node pred;
	private Node desc;	
	private double wheight;
	private double capacity;
	private boolean flag;
}

Wir müssen mit recht großen Graphen umgehen (Kantenanzahl ca. 5.000.000) diese werden aus einer Textdatei eingelesen. Mir ist jetzt beim (wohl recht naivem) Einsatz eines Profilers aufgefallen, dass beim erstellen des Graphen neben der genauen Anzahl an Knoten und Kanten noch mehrere Millionen von weiteren (allerdings unbekannten) Arrays erstellt werden und wohl nicht mehr verschwinden. Da das ganze dann nur läuft, wenn ich ihm mehr als 500 MB Speicher (was zu viel ist...) zuweise, bin ich auf Fehlersuche. Die erste Frage war eigentlich nur allgemein gemeint. Im speziellen habe ich z.b. diese Schleife (Sie erstellt die Kanten):

int i =0;
while( ((line = br.readLine()) != null ) ){
        	   if(!line.equals("")){	//Sicher gehen, keine leeren Zeilen aufzunehmen
        		   	String arcAsString = line;
       				StringTokenizer arcAsToken = new StringTokenizer(arcAsString, "e ");
       				int node1Id = Integer.parseInt(arcAsToken.nextToken());
       				int node2Id = Integer.parseInt(arcAsToken.nextToken());
       				Node node1=nodes[node1Id];
       				Node node2=nodes[node2Id];
       				Arc arc = new Arc(node1, node2);
       				this.arcs[i] = arc;
       				i++;
              }
}

und nun war ich am überlegen, ob es z.B. sinnvoll ist, die ints node*Id und die Nodes eben außerhalb zu erstellen und nur die zuweisungen in der Schleife zu machen.
In den versch. Algorithmen kommt es dann doch häufiger so vor, wie im ersten Post beschrieben, wobei ich zur Zeit die 3. Variante verwende, mit Listen bzw. Arrays, die Knoten oder Kanten erhalten.

 

[Schumi]

ich behaupte mal bei Methode 3 fliegt dir irgendwann eine OutOfMemory Exception rum, da du immer wieder einen so grossen array intialisierst. Methode 2 find ich unsinnig - warum immer wieder den gleichen array neu initialisieren.....

In den versch. Algorithmen kommt es dann doch häufiger so vor, wie im ersten Post beschrieben, wobei ich zur Zeit die 3. Variante verwende...

Also ich werde mal versuchen, alles nach Methode 1 umzuschreiben und schau mal, ob bzw. in wie weit es sich verbessert.

Edit, nachdem ich gestern den ganzen Abend rumprobiert habe, ist mir dann heute morgen nach dem aufwachen eingefallen, dass es evtl. genau so besser gehen könnte...