[JAVA] Thread.interrupt()

[ragnonerodocet]

Continua la mia avventura attraverso i metodi dei thread...

Mi imbatto dunque nei metodi interrupt(), interrupted() isInterrupted().

Iniziamo dal primo.

Ho capito che se su un thread (in running???) viene chiamato interrupt(), su di questo un flag viene settato a true, e il thread si interrompe.
Cosa vuol dire che si interrompe? Che cessa la sua esecuzione? E in tal caso cosa succede al thread?

Il secondo metodo statico fa si che il flag, se settato a true, venga settato a false, ma non capisco l'utilità del metodo.

isInterrupted testa semplicemente se su un thread il flag è true o false, e restituisce un booleano come il metodo precedente...

Chi mi spiega come funziona precisamente il primo metodo e le differenze tra il secondo e il terzo metodo?

Qualche esempio è sempre graditissimo...

Arrivederci al prossimo metodo...

[ragnonerodocet]

Ho letto la documentazione della sun ma non credo di avere chiari determinati concetti...

[andbin]

Originariamente inviato da ragnonerodocet
Mi imbatto dunque nei metodi interrupt(), interrupted() isInterrupted().

La classe Thread ha in effetti un metodo stop() ma nella documentazione è chiaramente indicato "deprecated" e c'è un link ad una pagina che spiega perché è deprecato, perché non deve essere usato e cosa usare al posto di stop().

Ne avevo già parlato in questa discussione. Se non ti basta quello che era stato detto, si può approfondire qui. Ora purtroppo però non ho molto tempo.

[ragnonerodocet]

Da quello che ho capito, il fatto di invocare su un thread in esecuzione il metodo interrupt() comporta che un flag associato a quel thread da false diventi true.
Se tale metodo è invocato quando il thread è in wait, sleep o join allora si crea una InterruptedException.

A questo punto ho due domande.

1- da quello che ho capito, questo metodo può essere invocato su un thread sul quale è stata effettuata la chiamata start(): in altre parole, il thread NON deve essere per forza in stato running... È vero tutto ciò?

2- a questo punto, dopo aver capito interrupt(), credo che tale metodo serva solo se strettamente collegato ai due metodi sovracitati, interrupted() e isInterrupted, il primo statico il secondo no, entrambi che ritornano un booleano. Dato il valore restituito da tali metodi, immagino che il loro uso sia a sua volta legato a cicli if o while. In che modo dunque è utile usare l'uno o l'altro?

L'unica cosa che so è che il primo metodo, che è statico, ritorna true se il campo flag è posto su true, e inoltre, in tal caso, rende il flag false. Nel caso in cui il flag sia false, ritorna false. Ma non capisco perchè sia static... Se lo invoco in questa maniera

Thread.interrupted()

cosa fa?

Nel caso di isInterrupted, il flag non viene alterato e il metodo semplicemente ritorna true o false a seconda che il flag sia appunto impostato su true o false. A differenza del precedente metodo, capisco che sia NON static, perchè testa se uno specifico thread sia nello stato interrupt o meno.

Comunque, ritornando a quanto detto sopra, anche un piccolo esempio non sarebbe male.

@ gli amministratori: mi scuso se sommergo questo forum di domande a volte sciocche e senza senso, ma la pressione per l'esame di programmazione orientata agli oggetti si fa ogni giorno più incalzante.
@ admin: io l'esame non lo passerò mai (scaramanzia allo stato purissimo), ma mettiamo il caso in cui trovassi l'assistente più tranquillo in stato di grazia ed immensa generosità e strappassi un 17. 2 figure e un jolly, giuro che vengo dove abiti e ti dedico una statua a grandezza naturale con targa annessa recitante: "Quest'uomo ha fatto si che mi laureassi".

[Ed_Bunker]

Credo che con interrupted() si possa testare solo lo stato del thread corrente mentre con isInterrupted() puoi testare lo stato di altri thread (Padre, thread figli, etc.)

Nel caso di interrupted() il segnale viene quindi consumato, mentre nel caso di isInterrupted(), viene "solamente" letto.

Una chiamata a isInterrupted() sul thread corrente potrebbe essere equivalente a:

if (Thread.interrupted())
{
this.interrupt();
...
}
else
{
...
}