Newsgroup: it.comp.java
Titolo: Oggetto in un Singleton

Ciao a tutti,
ma se utilizzo un metodo di un singleton per gestire degli oggetti,
questi restano referenziati in qualche modo?
Mi spiego meglio:
Ho degli oggetti che gestisco la connessione al db, e nella finalize di
questi ho messo la close della PrepareStatemnt e una system.out .
Ho un singleton che utilizza questi oggetti nei sui metodi e non come
varibili della classe.
A me sembra che gli oggetti che gestiscono la connesione non sengono mai
distrutti (nella console non appare nulla) e che quindi
non viene mai richiamata la finalize...
E' possile ciň?
Oppure č solo un problema che il gc che non parte e che quindi non 
lancia la finalize....
Grazie...
--gio
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 --gio
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 
.... "che non parte" nel senso che non è richiamato perchè c'è ancora 
molta memoria  a disposizione e non viene attivato...
Ciao....


 Ciao....
la prossima volta telefonami...
anzi no meglio il ng così partecipano tutti



No, runFinalization() (ma perchè hanno messo questi metodi bastardi che poi ci 
si confonde???) può aumentare le possibilità che i tuoi finalizers vengano 
eseguiti ma NON lo garantisce.
Marco

 lancia la finalize....
Hmm.. ultimamente ho avuto modo di discutere questo tema... solo che non ho 
idea(è poco che bazzico i newsgroups) se si può fare un riferimento ad altri 
messaggi o no.... e allora ti faccio un grezzissimo cut-n-paste :)
Marco
////////// POST 1 ///////////
Sergio wrote:
 > Comunque e il metodo finalize (richiamato dal GC) dovrebbe risolverti il
 > problema, ma non ho ben capito come mai non riesci a ridefinirlo, anche s
 > eno so se ci sono delle limitazioni, non ho mai provato a farlo, ci provo e
 > ti faccio sapere se incontro qualche problema.
Ciao,
no, questo è un errore. Non ci sono garanzie che finalize() venga chiamato  in 
fretta
http://java.sun.com/docs/books/jls/second_edition/html/execution.doc.html#44748
e dunque nessuna operazione time-critical deve essere mai delegata a un 
finalizer(e chiudere connessioni a db, file ecc sono di queste).
Ad esempio dipendere da un finalizer per chiudere un file è rischioso perchè il 
numero di file descriptor che possono essere aperti dal SO sono limitati. Se 
troppi file restano aperti in attesa che il GC faccia pulizia e li chiuda 
potresti ritrovarti nella situazione dove il programma fallisca a causa del 
fatto che non ci sono più file descriptor disponibili...
Inoltre la rapidità con cui i finalizers vengono eseguiti è una funzione del 
algoritmo del GC, che cambia da VM a VM. È possibilissimo che con la VM che usi 
per sviluppare tutto funzioni alla grande ma una volta distribuita 
l'applicazione al tuo cliente(che usa un altra VM e non c'è verso di fargliela 
cambiare :) l'applicazione degradi miseramente... vai poi a fare test e 
debuggare per trovare il problema... ;)
Marco
////////// POST 2 ///////////
Ciao,
finalize() non è la controparte Java di un distruttore C++.
In C++ i distruttori sono lo strumento naturale per rilasciare risorse(memoria e 
non).
In Java per la memoria, si sa, c'è il GC, e per altre risorse(tipo files, 
threads, connessioni a db ecc.) si usa(o meglio, si può usare) un metodo di 
terminazione esplicita(explicit termination method).
Quando si vuole terminare un oggetto si invoca il suddetto metodo.
È necessario che l'oggetto in questione tenga traccia del proprio 
stato(valido/non valido). In poche parole il metodo di terminazione deve 
registrare in un membro privato dell'oggetto lo stato di quest'ultimo e gli 
altri metodi devono controllare il valore del membro e lanciare una 
IllegalStateException se vengono chiamati dopo aver terminato l'oggetto.
Il metodo close di OutputStream, per esempio, funziona esattamente in questo modo.
Normalmente i metodi di terminazione vengono usati in combinazione con il 
costrutto try-finally
Test test = new Test();
try {
     //usa test..
} finally {
     test.terminate() // Metodo di terminazione esplicita
}
Per sicurezza vale la pena, in caso l'utilizzatore si scordi di utilizzarlo, di 
inserire terminate() anche nel metodo finalize(). Ovviamente questo non ti 
garantisce che terminate() venga eseguito però potrebbre andarti bene.
Marco

 
Hmmm... qualche cosa č andato storto...

Gio Ghi wrote:
 > Ciao a tutti,
 > ma se utilizzo un metodo di un singleton per gestire degli oggetti,
 > questi restano referenziati in qualche modo?
 >
  No(a meno che non hai fatto qualche cosa di strano ;).
 > Ho degli oggetti che gestisco la connessione al db, e nella finalize di
 > questi ho messo la close della PrepareStatemnt e una system.out .
Suicidio!  :)
 > A me sembra che gli oggetti che gestiscono la connesione non sengono mai
 > distrutti (nella console non appare nulla) e che quindi
 > non viene mai richiamata la finalize...
 >
 > E' possile ciò?
 > Oppure è solo un problema che il gc che non parte e che quindi non lancia la 
finalize....


 Marco


 a result, the answer -- for me, and most likely for you -- is yes. 
Infatti, dipende dall'implementazione della VM. Il che non significa che se con 
la tua VM funziona, funzioni anche con tutte le altre VM in circolazione(e 
vogliamo restare portabili, vero? :).
Tutto questo vale pure per System.gc
Gli unici 2 veri metodi che chiamano per davvero tutti i finalizers quando li 
esegui sono System.runFinalizationOnExit e Runtime.runFinalizationOnExit ma sono 
cosi pieni di bachi che sono stati deprecati.
Marco

 
Si, ma non ho grossi problemi di accessi al db, praticamente devo
calcolare una serie di cose accedendo una volta al db ... 
poi la spedisco e finisce la... cmq leggendo il tuo post mi sono
 convinto di cercare un'altro posto dove chiuderla (la connessione).. 
ma il punto rimane..
secondo me la finalize non č richiamata neanche dopo molto tempo...
Probabilmente il  gc non parte finchč non č occupata un tot di
memoria...
č la spigazione piů convincente che mi sono dato (io pensavo che era
 sempre attivo in bg e appena poteva ripuliva la memoria ... 
ma non sembra che funzioni cosě)... inddagherň ancora con qualche
test...
Grazie delle info
Ciao


 test...
Esatto, in linea di massima il gc parte quando si supera una certa soglia di 
occupazione dello heap. Cmq varia da implementazione a implementazione...
Per avere + info puoi dare un'occhiata ai seguenti articoli.
http://wireless.java.sun.com/midp/articles/garbage/
http://wireless.java.sun.com/midp/articles/garbagecollection2/
Marco

Grazie 1000 x le info...
