Introduzione allo stato del thread Java con esempio: ciclo di vita di un thread

Pubblicato: 2019-01-11
Introduzione allo stato del thread Java con esempio

Stati del filo

Il diagramma seguente illustra i vari stati in cui un thread Java può trovarsi in qualsiasi momento durante la sua vita e quali chiamate di metodo causano una transizione a un altro stato. Questo diagramma non è un diagramma a stati finiti completo, ma piuttosto una panoramica degli aspetti più interessanti e comuni della vita di un thread.

Sei nel posto giusto se hai una delle seguenti domande:

  • Ciclo di vita di un thread in Java
  • Ciclo di vita e stati di un thread in Java
  • Comprensione degli stati dei thread Java

Il resto di questa pagina discute Thread's life cycle in termini di stato.

Stato del thread Java con esempio

Nuovo thread

L'istruzione seguente crea un nuovo thread ma non lo avvia lasciando il thread nello stato etichettato New Thread nel diagramma.

1
Thread myThread = new MyThreadClass ( ) ;

Quando un thread è nello stato New Thread , è semplicemente un oggetto Thread vuoto. Non sono state ancora allocate risorse di sistema per esso. Pertanto, quando un thread è in questo stato, puoi solo avviarlo o interromperlo; chiamare qualsiasi altro metodo oltre a start() o stop() quando un thread è in questo stato non ha senso e provoca un'eccezione IllegalThreadStateException.

eseguibile

Consideriamo ora queste due righe di codice:

1
2
Thread myThread = new MyThreadClass ( ) ;
myThread . start ( ) ;

Il metodo start() crea le risorse di sistema necessarie per eseguire il thread, pianifica l'esecuzione del thread e chiama il metodo run() del thread. A questo punto il thread è nello stato "Eseguibile". Questo stato è chiamato "Eseguibile" anziché "In esecuzione" perché il thread potrebbe non essere effettivamente in esecuzione quando si trova in questo stato. Molti computer hanno un unico processore che rende impossibile eseguire tutti i thread "Eseguibili" contemporaneamente.

Pertanto, il sistema di runtime Java deve implementare uno schema di pianificazione che condivida il processore tra tutti i thread "Eseguibili". Tuttavia, per la maggior parte degli scopi puoi pensare allo stato "Eseguibile" semplicemente come "In esecuzione". Quando un thread è in esecuzione, è "Eseguibile" ed è il thread corrente, le istruzioni nel suo run() vengono eseguite in sequenza.

Non eseguibile

Un thread entra nello stato Not Runnable quando si verifica uno di questi quattro eventi:

  • qualcuno chiama il suo metodo suspend()
  • qualcuno chiama il suo metodo sleep()
  • il thread usa il suo metodo wait() per attendere una variabile di condizione
  • il thread si blocca sull'I/O.

Ad esempio, la riga in grassetto in questo frammento di codice

1
2
3
4
5
6
Thread myThread = new MyThreadClass ( ) ;
myThread . start ( ) ;
try {
     myThread . sleep ( 10000 ) ;
} catch ( InterruptedException e ) {
}

mette myThread in stato di stop per 10 secondi (10.000 millisecondi). Durante quei 10 secondi, anche se il processore diventasse disponibile, myThread non funzionerebbe. Dopo che i 10 secondi sono trascorsi, myThread diventa di nuovo "Eseguibile" e ora se il processore diventasse disponibile myThread funzionerebbe.

Per ciascuno degli "ingressi" nello stato "Non eseguibile" sopra elencato, esiste una via di fuga specifica e distinta che riporta il thread allo stato "Eseguibile". Una via di fuga funziona solo per il suo corrispondente “ingresso”. Ad esempio, se un thread è stato messo in pausa, il numero specificato di millisecondi deve trascorrere prima che il thread diventi di nuovo "Eseguibile". La chiamata a resume() su un thread inattivo non ha alcun effetto.

Di seguito viene indicata la via di fuga per ogni ingresso nello stato “Non percorribile”.

  • Se un thread è stato messo in pausa, deve trascorrere il numero di millisecondi specificato.
  • Se un thread è stato sospeso, qualcuno deve chiamare il suo metodo resume() .
  • Se un thread è in attesa di una variabile di condizione, qualunque oggetto possieda la variabile deve abbandonarla chiamando notify() o notificationAll( notifyAll() .
  • Se un thread è bloccato sull'I/O, il comando I/O specificato deve essere completato.
java-thread-tutorial

Morto

Un filo può morire in due modi: o per cause naturali o per essere ucciso (fermato). Un thread muore naturalmente quando il suo metodo run() esce normalmente. Ad esempio, il ciclo while in questo metodo è un ciclo finito: eseguirà un'iterazione 100 volte e quindi uscirà.

1
2
3
4
5
6
7
public void run ( ) {
     int i = 0 ;
     while ( i < 100 ) {
i ++ ;
System . out . println ( "i = " + i ) ;
     }
}

Un thread con questo metodo run() morirà naturalmente dopo che il ciclo e il metodo run() () saranno completati.

Puoi anche terminare un thread in qualsiasi momento chiamando il suo metodo stop() . Questo frammento di codice.

1
2
3
4
5
6
7
Thread myThread = new MyThreadClass ( ) ;
myThread . start ( ) ;
try {
     Thread . currentThread ( ) . sleep ( 10000 ) ;
} catch ( InterruptedException e ) {
}
myThread . stop ( ) ;

crea e avvia myThread quindi mette in sospensione il thread corrente per 10 secondi. Quando il thread corrente si riattiva, la linea in grassetto nel segmento di codice myThread .

Il metodo stop() lancia un oggetto ThreadDeath sul thread per ucciderlo. Pertanto, quando un thread viene ucciso in questo modo, muore in modo asincrono. Il thread morirà quando riceve effettivamente l'eccezione ThreadDeath.

IllegalThreadStateException

Il sistema di runtime genera un'eccezione IllegalThreadStateException quando si chiama un metodo su un thread e lo stato di quel thread non consente quella chiamata al metodo. Ad esempio, IllegalThreadStateException viene generata quando si chiama suspend() su un thread che non è "Eseguibile".

Come mostrato nei vari esempi di thread finora in questa lezione, quando si chiama un metodo thread che può generare un'eccezione, è necessario catturare e gestire l'eccezione oppure dichiarare che il metodo chiamante genera l'eccezione non rilevata.

Il metodo isAlive()

E un'ultima parola sullo stato del thread: l'interfaccia di programmazione per la classe Thread include un metodo chiamato isAlive() . isAlive() restituisce true se il thread è stato avviato e non interrotto. Pertanto, se il metodo isAlive() restituisce false , sai che il thread è un "Nuovo thread" o un "Dead".

Se il metodo isAlive() restituisce true , sai che il thread è "Eseguibile" o "Non eseguibile". Non è possibile distinguere tra un thread "Nuovo thread" e un thread "Dead"; né puoi distinguere tra un thread "Eseguibile" e un thread "Non eseguibile".

Guardando esempi di thread complessi, ho trovato questo tutorial davvero fantastico in rete. Tutti dovrebbero leggerlo attentamente.