multithreading java tutorial with examples
Questo tutorial spiega tutto sul multithreading in Java, l'implementazione della concorrenza, il ciclo di vita di un thread, l'esempio della classe di thread, il thread che utilizza l'interfaccia eseguibile:
La concorrenza nel mondo dei computer è la capacità di un sistema (sia esso un'applicazione, un computer o un linguaggio di programmazione) di eseguire più istanze di un programma o di un'applicazione in parallelo.
Eseguendo istanze o programmi contemporaneamente, garantiamo un throughput elevato e prestazioni più elevate poiché possiamo utilizzare le risorse non sfruttate come l'hardware del sistema operativo, ecc. Per esempio, se un sistema dispone di più CPU, l'applicazione può utilizzarle in modo efficace e aumentare il throughput.
=> Visita qui per l'esclusiva serie di tutorial di formazione Java.
Cosa imparerai:
- Che cos'è il multithreading in Java
- Che cos'è un thread in Java
- Conclusione
Che cos'è il multithreading in Java
In Java, i thread possono essere visti come la spina dorsale della concorrenza. Un thread è un'unità eseguibile e leggera che accede alle risorse condivise e al proprio stack di chiamate.
Un'applicazione Java è un processo e all'interno di questa applicazione possiamo avere più thread per ottenere la concorrenza.
Sappiamo che un'applicazione in esecuzione sul sistema può avere più istanze e queste sono generalmente chiamate applicazioni multi-doc. Queste istanze dell'applicazione sono chiamate processi. A ciascuno di questi processi viene assegnata un'unità di esecuzione nota come thread.
A seconda del sistema operativo e dei requisiti dell'applicazione, al processo può essere assegnato un singolo thread o più thread. Quando al processo dell'applicazione vengono assegnati più thread, è necessario eseguire questi più thread contemporaneamente.
' Questa tecnica di esecuzione o esecuzione di più thread contemporaneamente o contemporaneamente è nota come multithreading . '
Multithreading significa semplicemente che abbiamo più di un thread in esecuzione all'interno della stessa applicazione.
Il linguaggio di programmazione Java ha il supporto integrato per il multithreading.
Il multithreading è illustrato nel diagramma sopra. Come illustrato, sono presenti più thread in esecuzione contemporaneamente all'interno di un'applicazione.
Per esempio, un'applicazione desktop che fornisce funzionalità come modifica, stampa, ecc. è un'applicazione multithread. In questa applicazione, poiché la stampa è un processo in background, possiamo eseguire la modifica dei documenti e stampare i documenti contemporaneamente assegnando queste funzioni a due thread diversi.
I thread nelle applicazioni multithread vengono eseguiti parallelamente tra loro in modo simultaneo. Quindi il multithreading fa anche parte della concorrenza in Java. Notare che sebbene ci siano più thread, condividono l'area di memoria risparmiando così sulla memoria. Inoltre, i thread possono facilmente cambiare contesto in pochissimo tempo.
Il multithreading è principalmente utile in quanto fornisce l'esecuzione simultanea di due o più parti di un'applicazione. Ciò consente all'applicazione di utilizzare il tempo della CPU al massimo e il tempo di inattività è ridotto al minimo.
I seguenti sono alcuni dei termini che dovremmo conoscere in relazione all'ambiente multithreading poiché vengono utilizzati frequentemente.
Multitasking: Nel multitasking, più di un'attività viene eseguita contemporaneamente.
Multithreading: Il multithreading, come già accennato, è un processo di esecuzione di più thread contemporaneamente.
ciclo di vita dei bug nei test del software
Multiprocessing: In multiprocessing, più di un processo viene eseguito contemporaneamente. Simile al multitasking, ma qui è coinvolta più di una CPU.
Elaborazione parallela: L'elaborazione parallela è una tecnica in cui più CPU lavorano contemporaneamente in un sistema informatico.
Dopo aver discusso il multithreading, sorge la domanda sul motivo per cui abbiamo bisogno del multithreading?
Vantaggi del multithreading
Il multithreading presenta diversi vantaggi che aiutano a una programmazione efficiente.
I punti seguenti lo chiariranno.
# 1) Utilizzo efficiente di sistemi a CPU singola
Quando c'è una sola CPU nel sistema, con un singolo thread, il tempo della CPU viene sprecato. Quando il thread è occupato utilizzando altre risorse come IO, la CPU è inattiva. Possiamo migliorare questo e utilizzare meglio la CPU disponendo di applicazioni multithread.
Utilizzando il multithreading, se un thread viene eseguito con la CPU, l'altro thread può utilizzarlo. Con più thread, il tempo di inattività della CPU sarà notevolmente ridotto.
# 2) Utilizzo efficiente di più sistemi CPU
Proprio come le CPU singole, anche con sistemi con più CPU, le applicazioni multithread sono in grado di utilizzare più CPU in modo efficiente.
# 3) Esperienza utente migliorata rispetto a reattività e correttezza
La reattività del sistema migliora con le applicazioni multithread. Non sperimentiamo il 'GUI in sospeso' quando abbiamo più thread che eseguono varie attività nell'applicazione e gli utenti non devono attendere molto tempo per ottenere una risposta alle loro richieste.
Allo stesso modo, gli utenti sono correttamente servizi nei sistemi multithread.
Come implementare la concorrenza in Java
La prima classe che utilizza la quale possiamo implementare la concorrenza in Java è java.lang.Thread classe. Questa classe Thread costituisce la base della concorrenza in Java.
Abbiamo anche java.lang.Runnable interfaccia che può essere implementata da una classe Java per astrarre il comportamento del thread. Per lo sviluppo di applicazioni avanzate, possiamo utilizzare il java.util.concurrent pacchetto disponibile da Java 1.5.
Andando avanti, discuteremo in dettaglio della concorrenza in Java. Discutiamo e comprendiamo il concetto di thread in Java in questo tutorial. Nelle nostre successive esercitazioni sul multithreading, esploreremo vari concetti di multithreading e concorrenza.
Che cos'è un thread in Java
Un singolo thread può essere definito come l'unità di elaborazione più piccola e leggera. In Java, i thread vengono utilizzati nei programmi che utilizzano la classe 'Thread'.
I thread Java sono di due tipi:
# 1) Thread utente: il thread utente viene creato al primo avvio dell'applicazione. Quindi possiamo creare quanti più thread utente e demone.
# 2) Thread daemon: i thread daemon vengono utilizzati principalmente in background e vengono utilizzati per attività come la pulizia dell'applicazione, ecc.
I thread riducono il costo di manutenzione dell'applicazione. Riduce anche il sovraccarico dell'applicazione.
Di seguito viene mostrato un esempio di thread singolo:
public class Main{ public static void main (String () args){ System.out.println('This is a thread'); } } Il programma di cui sopra mostrerà 'Questo è un thread' come quando l'applicazione avvia un thread utente viene creato. Nel programma sopra, la funzione principale è il punto di partenza dell'applicazione e crea un thread utente.
Il ciclo di vita di un filo
Il diagramma seguente illustra il ciclo di vita di un thread in Java.
Come mostrato nel diagramma sopra, un thread in Java ha i seguenti stati:
# 1) Novità: Inizialmente, il thread appena creato dalla classe thread ha uno stato 'nuovo'. Deve ancora essere avviato. Questo thread è anche chiamato 'Filo nato' .
# 2) eseguibile: In questo stato, l'istanza di un thread viene richiamata utilizzando il metodo 'inizio' .
# 3) In esecuzione: Il metodo di avvio dell'istanza del thread viene richiamato e il thread inizia l'esecuzione. Questo è lo stato di esecuzione. Per lo più lo scheduler pianifica e gestisce i thread.
# 4) bloccato: Ci sono più thread in un'applicazione. Questi thread devono attendere un altro poiché la loro esecuzione deve essere sincronizzata.
# 5) terminato: Una volta terminato il processo di esecuzione del thread, il thread viene terminato o la sua esecuzione viene interrotta.
Quindi viene prima creato un thread, quindi pianificato e successivamente lo scheduler esegue il thread. Mentre il thread in esecuzione può essere bloccato o sospeso per qualche altra attività. Quindi viene ripreso e mentre l'elaborazione viene completata, il thread viene eseguito.
Priorità thread
Una priorità del thread decide come un thread deve essere trattato rispetto agli altri thread in un'applicazione. Una priorità del thread è un numero intero.
Di seguito sono elencati alcuni punti da ricordare sulle priorità dei thread:
- Le priorità dei thread sono numeri interi.
- Usando la priorità del thread, possiamo decidere quando passare da un thread in stato di esecuzione a un altro. Questo è il processo di cambio di contesto in cui cambiamo i contesti dei thread.
- Ogni volta che un thread può rilasciare volontariamente il suo controllo sulla CPU. Quindi il thread con la priorità più alta può subentrare.
- Allo stesso modo, un thread con priorità più alta può precedere qualsiasi altro thread con priorità inferiore.
- La classe Thread fornisce un metodo setPriority () utilizzato per impostare la priorità per il thread.
- Possiamo anche utilizzare le costanti MIN_PRIORITY, MAX_PRIORITY o NORM_PRIORITY al posto degli interi.
Crea un thread
Possiamo creare un thread utilizzando uno dei seguenti modi:
- Estensione della classe 'Thread' di Java.
- Implementazione di 'Runnable'.
Estensione della classe 'Thread' Java
La classe 'Thread' contiene i costruttori e i metodi che ci consentono di creare ed eseguire operazioni su un oggetto thread. Internamente la classe Thread implementa l'interfaccia Runnable ed estende anche la classe Object.
La tabella seguente fornisce un riepilogo dei vari costruttori e metodi di una classe Thread ().
| Costruttore/ | Prototipo | Descrizione |
|---|---|---|
| dormire | public void sleep (lunghi millisecondi) | L'esecuzione del thread corrente viene interrotta per millisecondi specificati. |
| Thread () costruttore | Filo() | Costruttore predefinito per creare un oggetto Thread. |
| Thread (nome stringa) | Costruttore per creare un oggetto Thread con il nome specificato. | |
| Discussione (eseguibile r) | Crea un'istanza Thread con l'oggetto dell'interfaccia Runnable specificato. | |
| Thread (eseguibile r, nome stringa) | Crea un'istanza Thread con l'oggetto dell'interfaccia Runnable specificato e il nome specificato | |
| correre | public void run () | Il metodo Run esegue l'azione per un thread. Invoca il filo. |
| inizio | public void start () | Utilizzato per avviare l'esecuzione del thread. Internamente la JVM chiama il metodo run () su questo thread. |
| aderire | public void join () | Aspetta che il filo muoia |
| public void join (lunghi millisecondi) | Attendi i millisecondi specificati affinché il thread muoia. | |
| getPriority | public int getPriority () | Restituisce la priorità del thread |
| setPriority | public int setPriority (int priorità) | Modificare la priorità del thread in una priorità specificata |
| getName | public String getName () | restituisce il nome del thread. |
| imposta nome | public void setName (nome stringa) | Imposta il nome del thread sulla stringa specificata |
| currentThread | public Thread currentThread () | Restituisce il riferimento del thread attualmente attivo |
| getId | public int getId () | Restituisci ID thread |
| getState () | public Thread.State getState () | Restituisce lo stato corrente del thread |
| è vivo | public boolean isAlive () | Controlla se il thread è attivo e restituisci true se sì. |
| dare la precedenza | rendimento del vuoto pubblico () | Sospende temporaneamente il thread corrente e consente l'esecuzione di altri thread. |
| isDaemon | pubblico booleano isDaemon () | Controlla se il thread è un thread daemon; restituire true se si. |
| setDaemon | public void setDaemon (boolean b) | Imposta il thread come thread daemon se b = true; altrimenti impostato come thread utente. |
| interrompere | public void interrupt () | Interrompi il thread corrente. |
| isInterructed | public boolean isInterructed () | Controlla se il thread è interrotto. |
| interrotto | pubblico statico booleano interrotto () | Controlla se il thread corrente è stato interrotto. |
| dumpStack | Static void dumpStack () | Stampa una traccia dello stack del thread corrente nel flusso di errore standard. |
| sospendere | public void suspend () | Sospende tutti i thread. (** il metodo è deprecato nelle ultime versioni di Java) |
| curriculum vitae | public void resume () | Riprendi thread sospeso. (** il metodo è deprecato nelle ultime versioni di Java) |
| fermare | public void stop () | Arresta il filo. (** il metodo è deprecato nelle ultime versioni di Java) |
Elaboreremo questi metodi di thread nel nostro prossimo tutorial sul multithreading.
migliori siti per guardare anime gratis
Avvio di un thread
Il metodo start () utilizzato per avviare il thread esegue i seguenti passaggi:
- Avvia una nuova istanza di thread con un nuovo CallStack.
- Lo stato del thread viene modificato da nuovo a eseguibile.
- Quando è il turno del thread, esegue il metodo run ().
Implementazione dell'interfaccia 'eseguibile'
È inoltre possibile creare un'istanza di thread utilizzando l'interfaccia Runnable. Per creare un'istanza di thread, la classe i cui oggetti devono essere eseguiti da un thread deve implementare l'interfaccia Runnable.
L'interfaccia Runnable ha un solo metodo:
public void run () => this method is used to execute the thread. Esempio di classe di thread
Ora dimostriamo il thread in Java utilizzando la classe thread.
//class inherited from 'Thread' class ThreadClassDemo extends Thread { private int number; //class constructor public ThreadClassDemo(int number) { this.number = number; } //run method => execution code for thread public void run() { int counter = 0; int numInt = 0; //prints the number till specified number is reached, starting from 10 do { numInt = (int) (counter + 10); System.out.println(this.getName() + ' prints ' + numInt); counter++; } while(numInt != number); System.out.println('** Correct! ' + this.getName() + 'printed ' + counter + ' times.**'); } } public class Main { public static void main(String () args) { System.out.println('Starting thread_1...'); //create a thread class instance Thread thread_1 = new ThreadClassDemo(15); //start the thread thread_1 thread_1.start(); try { //wait for thread_1 to die thread_1.join(); } catch (InterruptedException e) { System.out.println('Thread interrupted.'); } System.out.println('Starting thread_2...'); Thread thread_2 = new ThreadClassDemo(20); //start thread_2 thread_2.start(); System.out.println('main() is ending...'); } } Produzione
Thread Java utilizzando l'interfaccia eseguibile
L'esempio seguente mostra l'uso dell'interfaccia Runnable per creare un'istanza di thread.
//class implements Runnable interface class RunnableDemo implements Runnable { private String message; //class constructor public RunnableDemo(String message) { this.message = message; } //run method public void run() { while(true) { System.out.println(message); } } } public class Main { public static void main(String () args) { //create first thread instance hello Runnable hello = new RunnableDemo('Hello, Greetings!!!'); Thread thread1 = new Thread(hello); thread1.setDaemon(true); //set this thread as daemon thread1.setName('hello'); System.out.println('Starting First thread...'); //start the thread thread1.start(); //create second thread instance bye Runnable bye = new RunnableDemo('Bye for now!!'); Thread thread2 = new Thread(bye); thread2.setPriority(Thread.MIN_PRIORITY); //set priority to min thread2.setDaemon(true); //set as daemon thread System.out.println('Starting goodbye thread...'); //start the thread thread2.start(); System.out.println('main() is ending...'); } }Produzione
Come fermare un thread in Java
Abbiamo visto gli esempi di thread sopra. Da questi esempi, sappiamo che quando il metodo run termina l'esecuzione, il thread si ferma o si ferma anche a causa di alcune eccezioni.
Le versioni precedenti di Java avevano un metodo stop () nella classe Thread che poteva essere utilizzato per arrestare direttamente il thread. Ma ora è stato deprecato per motivi di sicurezza. Quindi dobbiamo utilizzare gli altri metodi per fermare il thread in esecuzione.
Ci sono due metodi che possiamo utilizzare per fermare il thread.
- Utilizzo di una variabile booleana volatile
- Utilizzo degli interrupt.
In questa sezione, discuteremo entrambi questi metodi per arrestare un thread.
Utilizzo di una variabile booleana volatile
In questo metodo, manteniamo una variabile booleana come flag, per fermare il thread. Il thread viene eseguito finché la variabile booleana è impostata su true. Nel momento in cui diventa falso, il thread viene interrotto.
La specialità di questo metodo è che dichiariamo la variabile booleana come ' volatile 'In modo che venga sempre letto dalla memoria principale e il programma non possa memorizzarlo nella cache della CPU. In questo modo, non ci sarà alcuna differenza nei valori impostati e letti.
L'implementazione dell'arresto di un thread utilizzando una variabile booleana volatile è mostrata di seguito.
class StopThread extends Thread { private volatile boolean stop_flag = true; //initially set to true public void stopRunning() { stop_flag = false; //set stop_flag to false } @Override public void run() { while (stop_flag) { //keep checking value of stop_flag System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(10); } catch (InterruptedException e) { e.printStackTrace(); } //call stopRunning() method to stop the thread stop_thread.stopRunning(); } } Produzione
Nota: Qui abbiamo mostrato solo una parte dell'output. Il thread potrebbe essere eseguito per diversi minuti prima di arrestarsi. In questo modo possiamo ottenere output diversi su sistemi diversi.
Utilizzo degli interrupt
Qui il thread viene fermato usando il metodo interrupt () come abbiamo già discusso sopra nei metodi della classe thread. Il metodo interrupt () imposta lo stato del thread come interrotto. Questo stato viene passato al ciclo while del metodo run (). Possiamo ottenere lo stato interrotto usando il metodo interructed ().
Il seguente programma dimostra l'utilizzo del metodo interrupt () per arrestare il thread.
class StopThread extends Thread { @Override public void run() { while (!Thread.interrupted()) { //check for interrupted status System.out.println('Thread is running...'); } System.out.println('Thread stopped!!!'); } } public class Main { public static void main(String() args) { //create a thread instance StopThread stop_thread = new StopThread(); //start the thread stop_thread.start(); try { Thread.sleep(100); } catch (InterruptedException e) { e.printStackTrace(); } //interrupt the thread stop_thread.interrupt(); } } Produzione
Domande frequenti
D # 1) Perché utilizziamo il multithreading in Java?
Risposta: Il multithreading consente l'esecuzione simultanea o simultanea di due o più thread in un'applicazione. L'esecuzione simultanea massimizza il throughput e utilizza anche la CPU al massimo.
D # 2) Cos'è il multithreading? Quali sono i suoi tipi?
Risposta: Multithreading significa eseguire più di un thread. Questa esecuzione può essere simultanea o parallela. Pertanto, il multithreading ha due tipi, ovvero simultaneo o parallelo.
D # 3) Che cos'è il multithreading e il multiprocessing?
Risposta: Nel multithreading, ci sono più thread per processi uguali o diversi e questi thread vengono eseguiti contemporaneamente per migliorare la velocità di elaborazione di un sistema. Nel multiprocessing, un sistema ha più di due CPU e più processi vengono eseguiti contemporaneamente.
D # 4) Quali sono i vantaggi del multithreading in Java?
Risposta: Utilizzando il multithreading possiamo eseguire diverse parti di un'applicazione contemporaneamente utilizzando i thread. Il multithreading aumenta il throughput del sistema. Il multithreading massimizza anche l'utilizzo della CPU poiché diversi thread utilizzano continuamente la CPU.
D # 5) Il multithreading è buono per i giochi?
Risposta: Sì, soprattutto per i giochi moderni.
Conclusione
Si tratta solo dell'introduzione del multithreading. Abbiamo discusso la concorrenza e il multi-threading in Java in questo tutorial. Abbiamo discusso la creazione di un thread con la classe Thread e l'interfaccia Runnable e abbiamo fornito esempi appropriati.
Abbiamo anche appreso in dettaglio i concetti di un singolo thread e la sua creazione. I concetti del thread incluso il ciclo di vita di un thread, l'arresto di un thread, i tipi di thread, ecc. Sono stati discussi in questo tutorial.
Abbiamo anche discusso a lungo del multithreading e della concorrenza in Java. Alla fine di questo tutorial, il lettore dovrebbe essere in grado di cogliere facilmente i concetti di concorrenza e multithreading e anche di thread in Java.
=> Guarda qui la serie di formazione su Java semplice.
Lettura consigliata
- Multithreading in C ++ con esempi
- Thread Java con metodi e ciclo di vita
- Thread.Sleep () - Metodo Thread Sleep () in Java con esempi
- Tutorial JAVA per principianti: oltre 100 tutorial video Java pratici
- Tutorial Java Reflection con esempi
- Tutorial sul metodo Java String contains () con esempi
- Jagged Array in Java - Tutorial con esempi
- Tutorial di classe per scanner Java con esempi