Newsgroup: it.comp.java
Titolo: Distruggere un Thread

Ciao,
come faccio a interrompere l'esecuzione di un Thread?
Il mio T è sul server e sta in attesa di connessioni da parte di n client.
Per ogni client genero un nuovo Thread che lo gestisca.
Vorrei, alla pressione di un  bottone che piazzerò da qualche parte, 
terminare l'esecuzione del thread in attesa di connessione e di conseguenza 
anche quella dei thread che servono i vari client.
Avevo pensato a AttesaConnessioniThread.destroy(); ma i javaDoc dicono che 
non è implementato (infatti non funziona).
stop() è deprecato e non vedo altri metodi utili al mio scopo.
Come faccio?
Mi sono rotto tutte le volte che devo cambiare impostazioni al server di 
riavviare il programma.
Grazie
Cendo 

 come faccio a interrompere l'esecuzione di un Thread?
E' buona norma di programmazione terminare i thread "gracefully",
infatti non esistono metodi per stoppare un thread dall'esterno.
Nel tuo caso, il thread è bloccato con un ServerSocket in attesa.
Quello che devi fare è un metodo del thread, synchronized, che chiama
il close() del socket. Il thread intercetta l'eccezione che ne deriva e
termina in modo naturale uscendo dal run().

 ha scritto nel messaggio 
news:43ec3e2d$0$28073$4faf...@reader1.news.tin.it...

Un thread termina la propria esecuzione quando termina l'esecuzione del 
metodo run(), quindi basta che in qualche modo fai terminare questo metodo. 
Io in genere faccio così:
public class MioThread extends Thread { // o implements Runnable
...
boolean go = true;
...
public void run() {
    ... eventuali inizializzazioni
    while (go) {
        ... esecuzione ...
    }
    ... eventuali operazioni alla terminazione del thread, rilascio risorse 
ecc...
} // fine metodo run
public void close() {
    go = false;
} // fine metodo close
...
In questo modo dopo aver terminato il ciclo di esecuzione il thread 
controllerà la variabile "go" che può essere modificata dall'esterno. 
Infatti il metodo close() può essere invocato da altri thread. Così facendo 
il thread terminerà la propria esecuzione al successivo controllo della 
variabile "go", potendo anche rilasciare eventuali risorse.
In ultimo, in questo modo puoi realizzare il server con un thread centrale 
che riceve le richieste e avvia di conseguenza i thread che le gestiscono, 
facendo in modo che solamente il thread "centrale" sia sempre attivo e gli 
altri thread vengano creati/terminati su necessità.
Tax

 
Tutto questo è corretto.
Tuttavia esiste un caso in cui non è sufficiente.
Il thread centrale alza il flag di "richiesta morte dolce" per tutti i 
thread figli. Tutti, tranne uno o due, rispondono positivamente e 
muoiono. Quelli bloccati sono in uno stato di attesa bloccante (per 
esempio la lettura su un socket, o un file).
É pratica usuale, in questi casi, di aspettare un tempo massimo (20 
secondi, 5 secondi, dipende dall'applicazione) durante il quale il 
thread figlio può terminare le sue operazioni e crepare in modo pulito.
Ad attesa terminata, se il thread figlio è ancora bloccato, va terminato 
brutalmente (verosimilmente si trova in una situazione di deadlock o 
effettivamente non ci sono dati che arrivano sul canale sul quale è in 
ascolto).
A questo punto:
destroy non è implementato (cosa brutta, ma tant'è),
stop è deprecato (deprecato a favore di quale metodo? non mi sembra che 
venga detto)
La domanda diventa:
Come si fa a ordinare la morte di un thread fermo?
Questo è un caso limite, ma in applicazioni reali andrebbe gestito.
Luca
-- 

 venga detto)
fregatene e usa stop().
altrimenti usa una lettura non bloccante, in modo che quando arriva il
close() (dei post sopra) i thread non sono bloccati e possono terminare
normalmente.


Difatti è quello che faccio (con una bella direttiva di disabilitazione 
del warning. Odio avere warning :-) ).
Il problema è un altro:
Ora esiste stop (deprecato), ma domani?
non è sempre possibile utilizzare metodi non bloccanti (io su un 
connection pooler ho usato delle accept che uscivano comunque dopo un 
secondo giusto per vedere il flag di kill).
Speravo in qualche segnalazione di metodi o procedure non deprecate che 
permettessero comunque di killare un thread in caso di necessità.
Grazie comunque.
LP
-- 

>> come faccio a interrompere l'esecuzione di un Thread?
La cosa interessa anche me. Mi sembra che, utilizzando Thread.interrupt(),
si possa lanciare un'eccezione su un altro thread, dove, gestendo
l'eccezione
medesima, si può terminarlo... dall'interno.
Maggiori dettagli nei due link seguenti:
http://java.sun.com/j2se/1.4.2/docs/api/java/lang/Thread.html#interrupt()
http://www.di.unipi.it/~marcod/Didattica/LPCc/disp2/node41.html


Uhm, bella domanda... indagherò
Tax