Problemi di heap pieno e deallocazione memoria

[Neptune]

Salve a tutti,
se ho un istruzione del tipo:

while (it.hasNext()) {			
			lista_nodi2 = new ArrayList<Vertex>(insieme_nodi);

Ora ovviamente ad ogni iterazione del ciclo while associa all'etichetta "lista_nodi2" una nuova struttura dati. Di regola Java dovrebbe disallocare automaticamente le strutture dati non più indirizzabili mediante il garbate collector?

Eppure dopo qualche minuto di esecuzione continua del programma mi da eccezione dicendomi che la memoria dell'heap è terminata.
Non ce un modo per disallocarle manualmente? oppure magari per riutilizzare sempre la stessa lista?

[ramy89]

Una volta che un oggetto non è più denotabile, il garbage collector segna quella memoria come riutilizzabile.
Può anche non rimuovere gli oggetti dall' heap, ma se ha bisogno di memoria lo fa.
Allora i casi sono due:
1)insieme_nodi cresce man mano che si va avanti nell' iterazione;
2)lista_nodi2 viene salvato da qualche parte o rimane denotabile.

[Neptune]

Originariamente inviato da ramy89
Una volta che un oggetto non è più denotabile, il garbage collector segna quella memoria come riutilizzabile.
Può anche non rimuovere gli oggetti dall' heap, ma se ha bisogno di memoria lo fa.
Allora i casi sono due:
1)insieme_nodi cresce man mano che si va avanti nell' iterazione;
2)lista_nodi2 viene salvato da qualche parte o rimane denotabile.

Il codice è questo:

public void inserisci_archi(){
		Set insieme_nodi = g.vertexSet();
		ArrayList<Vertex> lista_nodi = new ArrayList<Vertex>(insieme_nodi);
		ArrayList<Vertex> lista_nodi2;
		ArrayList<Vertex> Nord=new ArrayList<Vertex>();
		ArrayList<Vertex> Nord_Est=new ArrayList<Vertex>();
		ArrayList<Vertex> Nord_Ovest=new ArrayList<Vertex>();
		ArrayList<Vertex> Sud=new ArrayList<Vertex>();
		ArrayList<Vertex> Sud_Est=new ArrayList<Vertex>();
		ArrayList<Vertex> Sud_Ovest=new ArrayList<Vertex>();
		ArrayList<Vertex> Est=new ArrayList<Vertex>();
		ArrayList<Vertex> Ovest=new ArrayList<Vertex>();
		Iterator<Vertex> it = lista_nodi.iterator();
		int h = 0;
		while (it.hasNext()) {			
			Vertex nodo1 = (Vertex) it.next();
			
			lista_nodi2 = new ArrayList<Vertex>(insieme_nodi);
			lista_nodi2.remove(h);
			h++;
			Iterator<Vertex> it2 = lista_nodi2.iterator();
			while (it2.hasNext()) 
			{
				Vertex nodo2 = (Vertex) it2.next();
				double dir=Funzioni_matematiche.azimuth(nodo1.get_centroide(), nodo2.get_centroide());
				String direzione=Funzioni_matematiche.stringa_azimuth(dir);
				if(direzione.compareTo("Nord")==0){
					Nord.add(nodo2);
				}
				if(direzione.compareTo("Nord-Est")==0){
					Nord_Est.add(nodo2);
				}
				if(direzione.compareTo("Nord-Ovest")==0){
					Nord_Ovest.add(nodo2);
				}
				if(direzione.compareTo("Sud")==0){
					Sud.add(nodo2);
				}
				if(direzione.compareTo("Sud-Est")==0){
					Sud_Est.add(nodo2);
				}
				if(direzione.compareTo("Sud-Ovest")==0){
					Sud_Ovest.add(nodo2);
				}
				if(direzione.compareTo("Est")==0){
					Est.add(nodo2);
				}
				if(direzione.compareTo("Ovest")==0){
					Ovest.add(nodo2);
				}
			}
			if(!Nord.isEmpty())
				calcola_distanza(nodo1,Nord,"Nord");
			if(!Nord_Est.isEmpty())
				calcola_distanza(nodo1,Nord_Est,"Nord-Est");
			if(!Nord_Ovest.isEmpty())
				calcola_distanza(nodo1,Nord_Ovest,"Nord-Ovest");
			if(!Sud.isEmpty())
				calcola_distanza(nodo1,Sud,"Sud");
			if(!Sud_Est.isEmpty())
				calcola_distanza(nodo1,Sud_Est,"Sud-Est");
			if(!Sud_Ovest.isEmpty())
				calcola_distanza(nodo1,Sud_Ovest,"Sud-Ovest");
			if(!Est.isEmpty())
				calcola_distanza(nodo1,Est,"Est");
			if(!Ovest.isEmpty())
				calcola_distanza(nodo1,Ovest,"Ovest");
		}		
	}

Poco sotto il primo while vedi che assegna a lista_nodi2 un new ArrayList di vertex.
Pià sotto nel codice vede quali Vertex di quell'arraylist gli interessano e gli aggiunge ad un'altra ArrayList mediante l'add.

Dici che quell'add non fa un clone degli elementi ma non fa altro che referenziare su più liste lo stesso elemento ed è per questo che poi non dealloca la lista? quale sarebbe la soluzione più adatta?

[ramy89]

Nord, Nord_Est,Nord_Ovest, ecc... sono tutti oggetti allocati nell' heap.
Se quel while dura tantissimo tu continui ad aggiungere elementi:

if(direzione.compareTo("Nord")==0){
					Nord.add(nodo2);
				}
				if(direzione.compareTo("Nord-Est")==0){
					Nord_Est.add(nodo2);
				}
				if(direzione.compareTo("Nord-Ovest")==0){
					Nord_Ovest.add(nodo2);
				}
				if(direzione.compareTo("Sud")==0){
					Sud.add(nodo2);
				}
				if(direzione.compareTo("Sud-Est")==0){
					Sud_Est.add(nodo2);
				}
				if(direzione.compareTo("Sud-Ovest")==0){
					Sud_Ovest.add(nodo2);
				}
				if(direzione.compareTo("Est")==0){
					Est.add(nodo2);
				}
				if(direzione.compareTo("Ovest")==0){
					Ovest.add(nodo2);
				}

Col risultato che le ArrayList Ovest,ecc... si gonfiano fino a occupare tutto l'heap.

[Alex'87]

Aumenta lo spazio riservato all'heap.
Qualche info qui

[Neptune]

Originariamente inviato da Alex'87
Aumenta lo spazio riservato all'heap.
Qualche info qui

Non ce qualche possibilità di aumentare la grandezza da dentro il codice Java in maniera tale che poi su qualsiasi macchina lo si esegue va?

[Alex'87]

Originariamente inviato da Neptune
Non ce qualche possibilità di aumentare la grandezza da dentro il codice Java in maniera tale che poi su qualsiasi macchina lo si esegue va?

No, non mi risulta. Si tratta di un'impostazione della jvm, una volta avviata non è più possibile andarle a modificare sotto i piedi questi settaggi "delicati".

[ramy89]

Vedi qua, ma alternativamente puoi controllare quanto spazio stai occupando, e salvarti tutto su file se l' heap è pieno, per poi svuotare le ArrayList.

[rsdpzed]

Ciao Nep. Premetto che non sviluppo in java ma in .net, mi permetto di rispondere perche linguaggio e framework sono molto simili.
credo che anche in java la GC sia non deterministica e quindi potenzialmente se lista_nodi2 è grossa anche se la precedente è candidata per essere trashata non è detto che lo sia all'atto di istanziare la successiva questo potrebbe essere una delle cause.
Se ho capito bene dal codice tu hai necessita di eseguire le operazioni matematche per ogni nodo della lista_nodi con tutti gli altri nodi. Per fare questo prima di creare l'iteratore it2 COPI l'intera lista in una lista_nodi2, elimini l'elemento h-esimo e poi ti crei it2... mi sembra troppo dispendioso. E se it2 lo creassi da lista_nodi e nel while interno controllassi prima di fare qualsiasi cosa che la posizione di it2 non sia h?
Non chiedermi come si fa in java (io ho i foreach, linq... ) ma sono sicuro che si possa faRE.
Spero di averti dato un aiutino e se cosi nn si risolve allora è probabile che bisognerebbe guardare la funzione calcola_distanza perche non vorrei che anche li per comodita copi gli arrayList dentro altri.
Ciao.