"Ciao, Amico!"
"Inizieremo un nuovo argomento: i thread."
"Cominciamo. Oggi esamineremo gli stati che un oggetto Thread attraversa (o potrebbe attraversare) quando un thread è in esecuzione."
"Quanti stati puoi nominare in questo momento, Amigo?"
"Due. Il primo è un thread prima che venga chiamato il metodo start(): l'oggetto esiste, ma il thread non è ancora attivo. E il secondo è dopo che il metodo start() è stato chiamato: quando il thread sta facendo qualcosa importante."
"Hai ragione, c'è una tale distinzione. Questi stati sono chiamati nuovo e funzionante , ma questo è solo l'inizio."
"In primo luogo, a un certo punto il thread terminerà l'esecuzione, il che significa che potrebbe esserci una situazione in cui esiste l'oggetto Thread, ma il thread non è nello stato nuovo o in esecuzione. "Questo stato, in cui il thread ha terminato l'esecuzione, è chiamato terminato ».
"Ma c'è di più. Non dimenticare che in un dato momento solo un thread è effettivamente in esecuzione. Ciò che sembra essere un lavoro simultaneo è in realtà il processore che salta costantemente da un thread all'altro. C'è uno stato separato per quando il thread sembra essere in esecuzione, ma in realtà sta aspettando il suo turno: si chiama ready-to-run . Mentre un thread funziona, passa costantemente da running a ready , quindi torna a running quando diventa di nuovo attivo."
"Immediatamente dopo la chiamata al metodo start (), al thread viene assegnato lo stato pronto per l'esecuzione e inserito in un elenco condiviso di thread tra i quali la JVM passa."
"Non è troppo difficile. Prima che inizi l'esecuzione, ha il nuovo stato. Dopo che è finito, è terminato . Quando è in esecuzione, il thread è nello stato in esecuzione ; quindi quando è in attesa, è nello stato pronto ."
"La tua brevità è sorprendente, ma hai ragione."
"Ma c'è di più. Il thread può essere bloccato. Ad esempio, quando si entra in un blocco sincronizzato . Se un thread arriva a un blocco di codice contrassegnato come sincronizzato e un altro thread lo sta utilizzando, il nostro thread entrerà nello stato bloccato e attenderà per il rilascio del mutex (blocco) dell'oggetto."
"Ecco come appare questa situazione con gli stati:"
"Ma c'è di più. C'è anche uno stato separato chiamato attesa . Questo è quando un thread non è bloccato , ma anche non pronto . Ad esempio, quando chiami il metodo join () su un altro thread."
Quando chiamiamo join() su un altro oggetto Thread, è come se il nostro thread lo «unisse», ma in realtà aspetta solo che l'altro thread finisca.
"Inoltre, c'è anche il metodo wait () (dal trio di metodi wait/notify/notifyAll), che commuta un thread nello stato di attesa quando viene chiamato."
"Ehi."
"Aspetta un attimo! C'è ancora dell'altro. Un thread può dormire chiamando il metodo sleep, per esempio. C'è anche uno stato separato per questo. Si chiama « attesa temporizzata ». « attesa temporizzata » significa che il thread è in attesa di qualcosa per un tempo limitato. Se chiami un metodo wait con un parametro, come wait(timeout) o join(timeout), il thread entrerà nello stato di attesa temporizzato."
"Ecco il diagramma completo:"
"Hmm. È tutto? O ci sono altri 10 stati interessanti?"
"Per ora, è così."
"In pratica, puoi solo ricordare il primo diagramma. È più semplice. Ma il secondo è più preciso."
"Stranamente, ci sono molti diagrammi di stato dei thread su Internet e sono tutti diversi."
"Ecco perché ti ho dato questo diagramma: è il più completo e corretto."
"In questo diagramma, gli stati ready e running sono combinati in un unico blocco chiamato runnable. Sai perché?"
"No. È la prima volta che vedo una cosa del genere."
"La classe Thread ha una classe interna chiamata State , così come un metodo pubblico State getState() ."
public enum State
{
NEW,
RUNNABLE,
BLOCKED,
WAITING,
TIMED_WAITING,
TERMINATED;
}"Puoi sempre chiamare il metodo getState () su un oggetto Thread e scoprire il suo stato attuale. E, naturalmente, sarà uno dei valori dell'enumerazione State."
"Capisco. Quindi, gli stati reali sono all'interno della JVM, ma ci sono anche stati a cui puoi accedere tramite codice Java usando il metodo State getState()."
"E in quali circostanze lo userei?"
"Molto probabilmente, mai."
"Ma devi sapere cosa sta succedendo all'interno dei thread. Altrimenti, avrai molti bug e non sarai nemmeno in grado di indovinare cosa li sta causando."
"Inoltre, i datori di lavoro adorano chiedere informazioni sugli stati dei thread durante i colloqui".
GO TO FULL VERSION