Java >> Programma Java >  >> Java

Java Multithreading - "Perché la tua conoscenza di Java è incompleta senza di essa

Il multithreading è un'altra importante caratteristica della programmazione orientata agli oggetti. Il multithreading in Java consente l'esecuzione simultanea di più di due programmi e possiamo utilizzare la capacità della CPU.

In questo tutorial Java impareremo cos'è il multithreading, i vantaggi del suo utilizzo e come implementare il multithreading in Java.

Prima di discutere del multithreading in Java, dovremmo conoscere i thread in Java. Quindi iniziamo con i thread in Java.

Per tenerti aggiornato sulle ultime tendenze tecnologiche, unisciti a TechVidvan su Telegram

Cos'è un thread Java?

Un thread è solo una singola parte leggera e più piccola di un processo. È l'unità più piccola di un processo che può essere eseguita contemporaneamente alle altre parti (altri thread) dello stesso processo.

Possono esserci più processi in un'applicazione. Ogni processo può avere un singolo thread o più thread. Il multithreading è il processo di esecuzione simultanea di più thread.

Esiste un'area di memoria comune per tutti i thread di un processo, ma ognuno di essi è indipendente l'uno dall'altro perché tutti hanno percorsi di esecuzione separati. Pertanto, se si verifica un'eccezione in un thread, non influisce sull'esecuzione di altri thread.

La figura sopra mostra che un thread viene eseguito all'interno del processo. C'è un cambio di contesto tra i thread. Possono esserci più processi all'interno del sistema operativo e possono esserci più thread in un processo.

Nota: È possibile eseguire un solo thread alla volta.

Multitasking vs Multithreading vs Multiprocessing vs Multiprogrammazione

Avresti confusione con Multitasking, Multithreading, Multiprocessing e Multiprogramming. Confrontiamoli brevemente per avere una migliore comprensione di tutti loro.

Multitasking: Il multitasking è la capacità di un sistema operativo di eseguire più attività o lavori contemporaneamente su una risorsa condivisa.

Multithreading: Il multithreading è la capacità di un sistema operativo di eseguire più thread contemporaneamente. Qui, un singolo processo è suddiviso in più thread.

Multielaborazione: È simile al multitasking ma qui c'è più di un processore o CPU. Pertanto, più processi possono essere eseguiti con più processori contemporaneamente.

Multiprogrammazione: La multiprogrammazione è la capacità di eseguire più di un programma contemporaneamente all'interno di una singola macchina. Ad esempio, eseguire contemporaneamente Excel e Firefox.

Priorità dei thread in Java

Con la creazione del thread Java, la JVM gli assegna una priorità che aiuta il sistema operativo a determinare l'ordine di pianificazione dei thread. Possiamo anche impostare la priorità del thread in modo esplicito.

L'intervallo valido di una priorità di un thread è compreso tra 1 e 10. I thread con priorità più elevate devono essere allocati prima dei thread con priorità più basse.

3 Costanti per la definizione delle priorità dei thread

Esistono 3 tipi di variabili o valori statici per definire le priorità dei thread. La tabella mostra queste variabili:

Variabile Descrizione
int statico pubblico MIN_PRIORITY La priorità minima di un thread con valore =1
int statico pubblico NORM_PRIORITY La priorità predefinita di un thread con valore =5
int statico pubblico MAX_PRIORITY La priorità massima di un thread con valore =10

Ciclo di vita del thread Java

I thread esistono in diversi stati. La figura sopra mostra le varie fasi del thread che sono:

  1. Nuovo stato
  2. Eseguibile stato
  3. Correndo stato
  4. In attesa stato
  5. Morto stato

1. Nuovo

Il thread è il nuovo stato quando lo creiamo utilizzando la "Classe di thread" . Rimane in questo stato finché il programma non avvia il thread chiamando il metodo start(). Viene anche chiamato filo nato.

2. Eseguibile

In questa fase, il metodo start() richiama l'istanza del thread. Lo scheduler prende il controllo del thread per completare l'esecuzione. Dipende dallo scheduler se eseguire o meno il thread.

3. In esecuzione

Il thread passa allo stato di esecuzione quando inizia la sua esecuzione. Lo scheduler seleziona un thread dal pool di thread e il thread inizia l'esecuzione nell'applicazione.

4. In attesa

È necessaria la sincronizzazione tra i thread poiché più thread sono in esecuzione nell'applicazione. Quindi, un thread deve attendere, finché l'altro thread non termina la sua esecuzione. Pertanto, diciamo che il thread è in stato di attesa.

5. Morto

Quando il thread viene terminato, il thread passa allo stato morto.

Vantaggi del singolo thread

I vantaggi dell'utilizzo dei thread sono:

  • Un thread riduce l'overhead nell'applicazione poiché un thread singolo viene eseguito nel sistema
  • Un singolo thread riduce i costi di manutenzione dell'applicazione.
  • I thread hanno un'area di memoria condivisa, quindi aiutano a risparmiare memoria.
  • Il passaggio da un thread all'altro richiede meno tempo rispetto al processo.

Multithreading in Java

Il processo di esecuzione simultanea o simultanea di più thread in un programma o un'applicazione è chiamato Multithreading in Java. Quando più di due thread vengono eseguiti contemporaneamente, è multithreading.

Pertanto, possiamo anche chiamarlo Concurrency in Java. Il multithreading consente l'esecuzione simultanea di più attività nello stesso programma in modo da ottenere il massimo utilizzo della CPU.

Come discusso in precedenza, il multitasking è un processo di esecuzione o esecuzione di più processi o attività contemporaneamente.

Il multithreading espande l'idea del multitasking in cui possiamo separare una singola applicazione in singoli thread ed eseguire ciascun thread in modo indipendente all'interno dello stesso spazio di memoria. Ciascun thread in un programma multithread può essere eseguito in parallelo.

Il sistema operativo divide il tempo di elaborazione tra le diverse applicazioni e anche tra ogni thread all'interno di un'applicazione.

Metodi di classe Thread in Java

L'elenco seguente mostra alcuni importanti metodi disponibili nella classe Thread.

S.N. Metodo Descrizione
1 inizio vuoto pubblico() Questo metodo inizia l'esecuzione del thread in un percorso separato e quindi chiama il metodo run() sull'oggetto Thread corrente.
2 esecuzione vuota pubblica() L'oggetto eseguibile richiama questo metodo se istanziamo questo oggetto Thread utilizzando un target Runnable separato.
3 public final void setName(String name) Questo metodo cambia il nome dell'oggetto Thread.
4 Pubblico void finale setPriority(int priority) Utilizziamo questo metodo per impostare la priorità di questo oggetto Thread. Possiamo utilizzare possibili valori compresi tra 1 e 10.
6 Pubblico final void join(lungo millisec) Il thread corrente chiama questo metodo su un secondo thread e fa sì che il thread corrente si blocchi finché il secondo thread non termina per il numero specificato di millisecondi passati.
7 Interruzione vuota pubblica() Questo metodo interrompe il thread corrente e ne fa continuare l'esecuzione se fosse stato bloccato per qualsiasi motivo.
8 pubblica booleana finale isAlive() Restituisce true se il thread è vivo o è ancora in esecuzione, altrimenti restituisce false.
9 rendimento vuoto statico pubblico() Fa sì che il thread attualmente in esecuzione ceda a tutti gli altri thread con la stessa priorità in attesa di essere pianificati.
10 sonno vuoto statico pubblico (lungo millisec) Arresta il thread attualmente in esecuzione per almeno il numero specificato di millisecondi.
11 Thread statico pubblico currentThread() Restituisce un riferimento al thread attualmente in esecuzione, ovvero il thread che invoca questo metodo.

Come ottenere il multithreading in Java?

Possiamo ottenere il multithreading in Java in due modi:

  • Implementando il Eseguibile Interfaccia
  • Estendendo Thread classe

Discutiamo in dettaglio di questi due modi

1. Implementazione dell'interfaccia eseguibile in Java

Creazione di una classe Implementazione dell'interfaccia eseguibile è il modo più semplice per creare un thread. Per fare ciò abbiamo bisogno di una classe che implementi un unico metodo chiamato run( ). Per creare un thread utilizzando un'interfaccia Runnable, dovrai seguire tre passaggi di base:

Passaggio 1

Nel primo passaggio, devi implementare il metodo run() dell'interfaccia Runnable. Questo metodo funge da punto di ingresso per il thread e la tua logica aziendale completa sarà presente all'interno di questo metodo. La sintassi del metodo run() è la seguente:

public void run( )

Passaggio 2

Nel secondo passaggio, creerai un'istanza di un oggetto Thread utilizzando il seguente costruttore:

Thread(Runnable threadObject, String threadName);

Dove threadObject è un'istanza di una classe che implementa l'interfaccia Runnable e threadName è il nome del nuovo thread.

Passaggio 3

Una volta creato un oggetto Thread, puoi avviarlo chiamando il metodo start(), che effettua una chiamata al metodo run(). Di seguito è riportata una semplice sintassi del metodo start():

void start();

Codice per creare un thread implementando l'interfaccia Runnable:

package com.techvidvan.multithreading;
class MultithreadingDemo implements Runnable
{
  public void run()
  {
    try
    {
      System.out.println ("Thread " +Thread.currentThread().getId() +" is running");
    }
    catch (Exception e)
    {
      System.out.println ("Exception caught");
    }
  }
}
public class ImplementingRunnableInterface
{
  public static void main(String args[])
  {
    for (int count=0; count<5; count++)
    {
      Thread object = new Thread(new MultithreadingDemo());
      object.start();
    }
  }

}

Risultato:

Il thread 11 è in esecuzione
Il thread 13 è in esecuzione
Il thread 12 è in esecuzione
Il thread 14 è in esecuzione
Il thread 15 è in esecuzione

2. Estendere la classe Thread

Possiamo anche creare un thread creando una nuova classe che estende la classe Thread. Quindi, questa classe sovrascrive il metodo run() e quindi creiamo un'istanza di questa classe. Quando chiami il metodo start(), il metodo run() viene eseguito.

La creazione di thread utilizzando la classe Thread è più flessibile rispetto alla creazione tramite l'interfaccia Runnable Perché è facile gestire più thread creati utilizzando i metodi disponibili nella classe Thread.

Ecco un semplice processo passo passo per creare una sottoclasse Java Thread:

Passaggio 1

Come primo passaggio, è necessario sovrascrivere il metodo run() della classe Thread. Questo metodo è un punto di ingresso per il thread e tutta la logica aziendale è presente all'interno di questo metodo.

La sintassi del metodo run() è la seguente:

public void run( );

Passaggio 2

Dopo aver creato un oggetto della sottoclasse Thread, è possibile avviarlo chiamando il metodo start(), che effettua una chiamata al metodo run(). Di seguito è riportata una semplice sintassi del metodo start():

void start( );

Codice per creare un thread estendendo la classe Thread:

package com.techvidvan.multithreading;
class MultithreadingDemo extends Thread
{
  public void run()
  {
    try
    {
      System.out.println("Thread " +Thread.currentThread().getId() +" is running");
    }
    catch (Exception e)
    {
      System.out.println ("Exception caught");
    }
  }
}
public class ExtendingThreadClass
{
  public static void main(String[] args)
  {
    for (int count=0; count<5; count++)
    {
      MultithreadingDemo object = new MultithreadingDemo();
      object.start();
    }
  }
}

Risultato:

Il thread 11 è in esecuzione
Il thread 12 è in esecuzione
Il thread 13 è in esecuzione
Il thread 14 è in esecuzione
Il thread 15 è in esecuzione

Vantaggi del multithreading in Java

  • Il multithreading consente di eseguire più operazioni contemporaneamente.
  • Risparmia tempo in quanto può essere possibile eseguire più operazioni.
  • I thread sono indipendenti l'uno dall'altro, il che migliora la funzionalità.

Riepilogo

Da questo articolo, siamo venuti a sapere che Java è un linguaggio di programmazione multi-thread, il che significa che possiamo sviluppare un programma multi-thread utilizzando Java. Con il multithreading in Java, possiamo dividere una particolare attività all'interno di una singola applicazione in più thread.

Il metodo start() avvia l'esecuzione del codice scritto nel metodo run(). Se ometti il ​​metodo start() nel tuo codice, anche il codice all'interno di run() non viene eseguito!!

Quindi, ora conosci il ciclo di vita del thread e come ottenere il multithreading in Java. Ci sono molti metodi in una classe thread che abbiamo trattato in questo articolo. Il multithreading ti aiuterà sicuramente ad entrare nel mondo dell'industria dei giochi.

Grazie per aver letto il nostro articolo. Se hai domande relative al multithreading Java, faccelo sapere lasciando un commento qui sotto.

Buon apprendimento 🙂


Etichetta Java