Newsgroup: it.comp.java
Titolo: Thread morti!!

volevo sapere cosa si intende con quest'espressione.
mi spiego un pň meglio: ho letto nella documentazione che il metodo join
della classe
thread attende un tot di secondi prima di far morire il thread ma questo
cosa significa:
- termina l'esecuzione del metodo run e basta
- č come se il thread fosse stato messo a null, per cui non posso piů
neppure chiamare altri metodi che possiede.
In pratica un thread morto ha ancora un suo perchč o sta solo aspettando
che il GC se lo porti in cielo?
Grazie Veruska

cosa significa:
Aspetta, se non ricordo male t.join() o t.join(long n) non interviene
sul thread t, ma semplicemente interrompe l'esecuzione del thread
corrente (al max per un certo tempo, o all'infinito) aspettando la
morte di t, che deve avvenire per "cause proprie". Quindi forse ti
stai confondendo.
Grazie comunque per avermi ricordato dell'esistenza del metodo join
:-)
(ma perche' poi "unisci"? che c'entra con aspettare la fine di un
thread?!)
Ciao,
 P.
+++ Boing Boom Tschak

> volevo sapere cosa si intende con quest'espressione.
Aaaargh, ho lasciato  a casa il Gosling :(....  Perché quello che dice
Piero :
PC> Aspetta, se non ricordo male t.join() o t.join(long n) non interviene
PC> sul thread t, ma semplicemente interrompe l'esecuzione del thread
PC> corrente (al max per un certo tempo, o all'infinito) aspettando la
PC> morte di t, che deve avvenire per "cause proprie". 
(O che qualcuno interrompa il  thread.) è corretto, quindi pare che il
thread rimanga alive (e chi lo ammazza ??? Devo rileggermi la cosa...) 
PC> Grazie comunque per avermi ricordato dell'esistenza del metodo join
PC> :-)
Mi associo...
PC> (ma perche' poi "unisci"? che c'entra con aspettare la fine di un
PC> thread?!)
Deriva dal gergo comune nel multithreading/parallelo. Tutto deriva dal
fatto  che  si  tratta   (tratterebbe  ?)  "ricongiungere"  flussi  di
esecuzione paralleli.
              +Thread
1 Thread    _________
           /         \     
----------<----------->--------------
           \_________/ 
         'fork'     'join'
\begin{avviso}
 
Attenzione: Leggersi lo header riguardo al mio e-mail!
Warning: read header for infos about my e-mail.
\end{avviso}
+----------------------------------------------------------------+
| Gian Uberto Lauri * "So, are you working on fixing that bug    |
| 
sa...@eng.it
      *  *now* or leaving it until later ?" - YES  |
+----------------------------------------------------------------+

 +++ Boing Boom Tschak
Grazie e scusa la zucconaggine

 Deriva dal gergo comune nel multithreading/parallelo.
Gia', potevo immaginarmelo.

grado di rispondermi?
Un thread "muore" (dopo una start()) quando 
 - run() termina
 - tutti i riferimenti all'oggetto Thread sono fuori scope.
Occhio che un conto e' un oggetto Thread per cui ci sono riferimenti in scope 
(e che quindi non e' soggetto a garbage collection), un altro e' un oggetto 
Thread *attivo* (quello che di solito si intende con thread "vivo").
Se hai riferimenti al thread, puoi invocarci metodi senza problemi. Se hai 
lanciato start() e poi tutti i riferimenti sono andati fuori scope, non puoi 
piu' invocarci metodi ovviamente, ma lui continua a essere attivo finche' run() 
non termina. 
Quindi se il tuo thread fa una listen() su una socket all'interno del suo 
metodo run(), e' responsabilita' tua far si che "muoia" o continui a "vivere" 
in caso di timeout expiration: dipende da quello che scrivi all'interno di run
().
-- 
God is Real, unless declared Integer.
ObjectZone - 
http://space.tin.it/computer/csadun

 s=null;
La tecnica giusta e' quella spiegata in questa guida di Sun:
http://java.sun.com/j2se/1.3/docs/guide/misc/threadPrimitiveDeprecation
.
html
che in effetti chiarisce alcuni dei miei dubbi, e ribadisce il fatto che
"uccidere" un thread non e' in generale un'operazione scontata.
--- cut
How do I stop a thread that waits for long periods (e.g., for input)?
That's what the Thread.interrupt method is for. The same "state based"
signaling mechanism shown above can be used, but the state change
(blinker = null, in the previous example) can be followed by a call to
Thread.interrupt, to interrupt the wait:
    public void stop() {
        Thread moribund = waiter;
        waiter = null;
        moribund.interrupt();
    }
For this technique to work, it's critical that any method that catches
an interrupt exception and is not prepared to deal with it immediately
reasserts the exception. We say reasserts rather than rethrows, because
it is not always possible to rethrow the exception. If the method that
catches the InterruptedException is not declared to throw this (checked)
exception, then it should "reinterrupt itself" with the following
incantation:
    Thread.currentThread().interrupt();
This ensures that the Thread will reraise the InterruptedException as
soon as it is able.
------------------------------------------------------------------------
--------
What if a thread doesn't respond to Thread.interrupt?
In some cases, you can use application specific tricks. For example, if
a thread is waiting on a known socket, you can close the socket to cause
the thread to return immediately. Unfortunately, there really isn't any
technique that works in general. It should be noted that in all
situations where a waiting thread doesn't respond to Thread.interrupt,
it wouldn't respond to Thread.stop either. Such cases include deliberate
denial-of-service attacks, and I/O operations for which thread.stop and
thread.interrupt do not work properly.
--- cut

 lungo.
Era piu' o meno la domanda che avevo fatto qualche tempo fa, anche se mi
riferivo a I/O bloccante in generale. Leggiti anche le altre risposte
che ho appena scritto, in quel documento di Sun dovresti trovare degli
spunti.
Nel tuo caso specifico, pero', hai la soluzione gia' pronta senza
toccare il thread impostando un timeout alla lettura dal socket con il
metodo setSoTimeout.

  - tutti i riferimenti all'oggetto Thread sono fuori scope.
ho dei seri dubbi su questo...
-- 
Ciao,  |  I play Russian roulette everyday, a man's sport,
Matteo |  With a bullet called life, yeah called life, (SUGAR)

ho dei seri dubbi su questo...
Le due cose, va da se', sono in "and".


 
ah bhe`, allora... ok  (mi sembrava strano le avessi messe in "or"! ;)



