Introduzione al ciclo di vita dei thread in Java
Un thread sperimenta numerose fasi del ciclo di vita. Ad esempio, un filo viene nel mondo, iniziato, corre e poi muore. Il diagramma seguente spiega il ciclo di vita completo della filettatura.
- Il costruttore di thread produce un thread attraverso un nuovo stato.
- Chiamare inizia il metodo in Thread può farlo attraverso lo stato eseguibile.
- Thread Scheduler relativo a Java esegue quel thread alla ricezione del processore.
- Quando il thread passerà a uno stato bloccato, verrà eseguito nuovamente perché torna a uno stato eseguibile.
- Se il metodo wait viene definito thread in attesa dello stato, passerà allo stato eseguibile subito dopo che diventerà notifica in tutto il metodo Inform e notifica a tutto.
- Il thread termina quando termina il metodo di esecuzione.
Cos'è il thread?
Un thread è definito a livello di sistema operativo. E il linguaggio Java, così come tutte le altre lingue, utilizza, sfrutta il servizio offerto dal sistema operativo. Dal punto di vista dello sviluppatore, un thread è un insieme di istruzioni che scriveremo la nostra applicazione ed eseguiremo in un certo modo. Un'applicazione stessa può essere composta da più thread. È possibile eseguire thread diversi contemporaneamente. La JVM (Java Virtual Machine) funziona con diversi thread. Esistono thread per la garbage collection. Esistono thread per il compilatore Just in Time e altri thread tecnici.
Ciclo di vita degli stati del thread in Java
Di seguito sono riportati i diversi stati del ciclo di vita del thread in Java:
1. Nuovo: un nuovo thread inizia il loro ciclo di vita all'interno del nuovo stato. Continua a essere in questo stato prima che il programma inizi il thread. Inoltre, è noto come thread creato.
2. Runnable: dopo che un thread nato di recente può iniziare, il thread diventa runnable. Un thread con questo stato viene considerato eseguendo il loro processo.
3. Attesa: occasionalmente, una transizione del thread verso l'attesa intorno allo stato anche se il thread è in attesa di un altro thread per eseguire un'attività. Un thread passa allo stato eseguibile solo se un thread aggiuntivo indica il thread in attesa per continuare a essere eseguito.
4. Attesa a tempo: un thread eseguibile può facilmente il particolare a tempo in attesa che lo stato ottenga un intervallo di tempo specifico. Un thread con questo stato passa allo stato eseguibile una volta scaduto l'intervallo di punti o se si verifica l'evento che è realmente in attesa.
5. Terminato: un thread eseguibile passa allo stato terminato perché esegue il suo compito oppure termina.
Come creare un thread in Java?
Il modo più semplice per creare un thread in Java è utilizzare il Runnable Pattern. Devi prima creare un'istanza dell'interfaccia Runnable, che è molto semplice; c'è solo un metodo da implementare. Quindi passiamo questa istanza al costruttore della classe Thread. Quindi chiamiamo semplicemente il metodo start () di questo oggetto thread creato, per avviare un nuovo thread che eseguirà l'attività racchiusa nel nostro oggetto Runnable.
Quindi prima creiamo un'istanza di Runnable. C'è solo un metodo da implementare, che è chiamato metodo run (). Questo è il modello Java 7 per farlo, con un'istanza di una classe anonima. Ma possiamo anche usare un'espressione lambda per implementare un Runnable poiché esiste un solo metodo nell'interfaccia Runnable.
Creiamo discussioni su esempi molto semplici
Vedremo cosa può andare storto con una race condition che è con codice non sincronizzato che dovrebbe essere sincronizzato e ripareremo il nostro codice usando la sincronizzazione. Questo primo esempio è molto semplice, è molto semplice. Si tratta solo di creare un'attività.
Produzione:
Un'attività è un'istanza dell'interfaccia Runnable, chiamiamola runnable e possiamo implementare questa interfaccia usando un'espressione lambda. Questa attività viene assegnata a un nuovo thread ed eseguita nel contesto di questo thread. Quindi stamperemo solo il nome del thread che esegue questa attività. Sono in esecuzione in … Thread.currentThread () è un metodo statico della classe Thread che restituisce il thread che esegue l'attività corrente. E non ci resta che chiamare getName () su questo oggetto thread per restituire il nome di un thread. Quindi dopo aver creato un'istanza Thread t = new Thread. Passando questo eseguibile come parametro. Quindi questo thread eseguirà questo pezzo di codice. E per lanciarlo. t.start () questo è il metodo start () che dobbiamo chiamare. Quello che possiamo anche fare è dare un nome esplicito a questo thread usando t.setName ("Il mio thread"). E ora possiamo eseguire questo codice. Ora invece del metodo call start (), chiamiamo il metodo run () e, se eseguiamo questo codice, il problema è che l'attività viene eseguita correttamente, ma non viene eseguita nel thread che abbiamo creato. Viene eseguito nel thread principale che è il thread che esegue il metodo principale. Quindi questo metodo run () non dovrebbe essere chiamato se vogliamo lanciare un nuovo thread.
Produzione:
Metodi del ciclo di vita del thread in Java
I metodi descritti semplicemente da Thread sono presentati in Tabella.
| Tipi di dati | Nomi dei metodi di thread |
| Corda |
getName () Restituisce il nome di questa discussione |
| int | ottenere priorità ()
Restituisce la priorità del thread |
| booleano | è vivo()
Verifica se questo thread è ancora in esecuzione |
| vuoto | aderire()
Attende che questa discussione muoia (termina) |
| vuoto | correre()
Ogni volta che questo thread è stato creato utilizzando un singolo oggetto Runnable, dopo quello che viene solitamente chiamato il metodo run dell'oggetto Runnable; altrimenti, questo metodo non restituirà nulla. Ogni volta che è possibile estendere la classe thread e anche il metodo run () viene sovrascritto durante la sottoclasse, viene chiamato un metodo run () sovraccarico. |
| vuoto | setName ( nome stringa )
Modifica il nome con questo thread per renderlo comparabile al nome dell'argomento. |
| vuoto statico | sleep ( long millis ) genera Interrotto / Eccezione Fa riposare il thread attualmente in esecuzione la quantità richiesta di millisecondi. |
| vuoto statico | sleep ( long millis, int nanos ) genera InterruptedException
Causa la sospensione del thread attualmente in esecuzione (cessazione dell'esecuzione) per la quantità richiesta di millisecondi, nonché per la particolare quantità di nanosecondi. |
| vuoto | inizio()
Attiva questi thread per iniziare l'esecuzione; Java Virtual Machine chiama il metodo run di quel thread. |
| vuoto statico | dare la precedenza()
Attiva l'oggetto thread attualmente in pausa per breve tempo e consentire l'esecuzione di thread aggiuntivi. |
| Discussione statica | currentThread ()
Restituisce una menzione dell'oggetto thread attualmente in esecuzione. |
Conclusione
- Semplice da usare usando i thread, estremamente difficile da capire.
- Progettare classi che contengono metodi che possono essere protetti da thread è impegnativo.
- Leggi: JavaDoc per ottenere la classe java.lang.Thread
Articolo raccomandato
Questa è stata una guida al ciclo di vita del thread in Java. Qui discutiamo cos'è il thread? e diversi stati del ciclo di vita del thread insieme alla creazione di thread in java. Puoi anche consultare i nostri altri articoli suggeriti per saperne di più -
- Strutture in Java
- Motivi a stelle in Java
- Unisci ordinamento in Java
- I migliori compilatori Java
- Metodo statico in PHP