Newsgroup: it.comp.java
Titolo: Out of space con thread

Salve a tutti. Avrei una domanda da porvi. Ho creato dei thread che
lavorano in modo concorrete. Quando le eseguo, lavorano correttamente e
non ho nessun problema. Al loro interno poi essi generano però
parecchie altre istanze di classi.
Ora, ho provato ad utilizzare in ciclo, per eseguire una serie di test,
creando iterativamente questi thread ed eseguendoli. Ad un certo punto
però ottengo l'eccezione che mi indica che java non ha più spazio nello
heap. Ora, a me non interessa che questi thread continuino a vivere. Ad
ogni iterazioni possono anche essere distrutti tranquillamente, io li
voglio creare nuovi. Il problema è che evidentemente come li ho fatti
io, loro continuano a vivere, quindi ad ogni iterazione ne aggiungo.
Nelle javadoc non sono riuscito bene a capire se esiste un metodo per i
Thread che mi permetta di interrompere il thread, perderlo anche
completamente, compresi tutti gli oggetti che ha creato.
Pensavo che bastasse porre a null il riferimento ai thread, ma
evidentemente non è così, perché mi pare che i thread continuino ciò
che stavano facendo e gli oggetti da loro creati pure. Qualcuno sa
darmi qualche suggerimento?
Grazie mille!



Il thread deve morire di sua spontanea volontà.
Devi fare in modo, magari cambiando una variabile condivisa, che il thread  
esca dal metodo run, un return; potrebbe esser sufficiente
-- 
Manny Calavera
Mail To: anforagimailpuntocom²
Uccidete i filosofi, tenetevi riso e bacchette per voi

Luca ha scritto:

intanto, i thread terminano quando escono dal metodo run().
va poi detto che il lifecycle delle istanze create all'interno dei 
thread *non* dipende dal thread in cui sono state istanziate, la regola 
del garbage collector vale a prescindere e tali istanze vengono 
candidate alla distruzione quando non sono più referenziate, che il 
thread sia terminato o meno.
ciò premesso: una diagnosi così a occhio è difficile farla, devi prima 
appurare se è vero che i thread restano appesi (non ci vuole granchè a 
capirlo) e una volta risolto questo se ne riparla.

 Grazie mille!
Su *nix basta che fai un kill -3 del processo java e dal thread dump 
leggi quali thread ci sono nella tua applicazione ... su windows... I 
don't sucche :)
ciao
Pier

 thread sia terminato o meno.
Ma sei sicuro?
mi stai dicendo dunque che un thread creato così
new Thread(){public void run(){...}}.run();
muore subito?


 muore subito ? 
il thread termina subito ma se la variabile con cui lo hai istanziato 
continua ad essere in scope non viene distrutto .... per distruggerlo o 
la variabile va fuori scope o la metti a null ... altrimenti se nella 
init del trhead .
ciao
PP

 muore subito?
ho detto che muore quando esce dal metodo run(), se nel metodo run non 
ci metti nulla muore subito, se ci metti un loop infinito non muore mai.
ps: comunque si chiama il metodo start() per avviare il thread :)

 leggi quali thread ci sono nella tua applicazione ... 
apperò. e per sapere se tua moglie è incinta come fai, l'ammazzi e le 
apri la pancia? :-)
c'è il debugger, eh... che magari dice anche qualcosa su cosa fanno di 
così dispendioso questi thread in esecuzione.

pier...@alice.it
 (16/09/2007 18.17.45):

Su Windows e su Linux (con X attivo), con JDK 6 (forse anche con il 5,
ma non ne sono sicuro)
- ottieni il pid del processo java di cui sei interessato
- lanci jconsole <pid>
- buon divertimento!
-- 
Scientology: se la conosci la eviti, se la conosci non ti uccide...
http://xenu.com-it.net
 - 
http://xenu.freewinds.cx
 - 
http://www.xenu.net
(per rispondere personalmente leva IlDitoDalCulo)
---> 09 F9 11 02 9D 74 E3 5B D8 41 56 C5 63 56 88 C0 <---

 apri la pancia? :-)
il kill -3 causa il dump dei thread ma nn la terminazione :)

Luca wrote:

La regola per la creazione di un thread è:
1) crei l'oggetto thread (o runnable)
2) avvi il thread con start()
3) quando il thread esce da run il thread muore
Se il thread non esce da run allora le risorse restano impegnate, se il
ciclo di creazione dei thread è più veloce di quanto i thread
possano "uccidersi" allora il garbage collector non ce la fa. Se sei sicuro
che i tuoi thread stiano uscendo da run allora forza una chiamata al
garbage collector nel ciclo di creazione. 
Le istanze che questi thread usano sono condivise? Intendo dire, restano
vive fra i vari thread? Hai provato ad usare anche jconsole per debuggare
l'applicazione e vedere il consumo di memoria? 
Il problema è nella creazione del thread o nella creazione degli oggetti del
thread? Nel primo caso i tuoi thread vivono, nel secondo sopravvivono le
variabili. Nota che se non avvii il thread con start (come ho visto in un
tuo commento) allora il thread è un normale oggetto in heap e non muore mai
(perché non va in esecuzione).
Luca