thread Java

Cos’è un thread:

Un thread è un singolo flusso sequenziale di istruzioni all’interno di un programma. Come un flusso di controllo sequenziale, un thread deve ritagliarsi alcune delle sue risorse all’interno del programma in esecuzione. Esso deve quindi avere il suo stack di esecuzione e un program counter.

  • Un thread è un singolo flusso sequenziale di istruzioni all’interno di un programma.
  • I thread possono essere creati in due modi:
    1. Extends class Thread 
    2. Implements Runnable

 

Ciclo di vita di un Thread:

I thread in Java

Java, al contrario di molti altri linguaggi, fornisce un supporto incorporato per la programmazione multithread. Un programma multithread contiene due o più parti che possono essere eseguite contemporaneamente. Ogni parte di un programma di questo tipo viene definita thread e ogni thread definisce un percorso separato di esecuzione. Ne consegue che il multithtreading è una forma specializzata di multitasking. In un ambiente multitasking basato sui thread, il thread è l’unità più piccola di codice inviabile. Questo significa che un singolo programma può eseguire contemporaneamente due o più attività. Per esempio un editor di testi può formattare il testo nello stesso momento in cui stampa, a patto che queste due azioni vengano eseguite da due thread separati. Il multithtreading permette di scrivere programmi molto efficienti, che sfruttano al massimo la CPU, dato che il periodo di inattività può essere ridotto al minimo. Tutto ciò è importante soprattutto per l’ambiente interattivo e di rete in cui opera Java, dato che i tempi morti sono consueti.

Quando un thread si blocca in un programma Java, soltanto quel singolo thread effettua una pausa, tutti gli altri thread continuano ad essere eseguiti.

Il multithreading permette ai cicli di animazione di “dormire” per alcuni millisecondi, senza provocare l’interruzione di tutto il sistema.

I thread esistono in diversi stati:

  • Un thread può essere in “esecuzione”;
  • Può essere “pronto per l’esecuzione” non appena ottiene il tempo dalla CPU;
  • Un thread in esecuzione può essere “sospeso”, il che significa che sospende temporaneamente la propria attività;
  • Un thread sospeso può essere “ripreso” dal punto in cui era stato sospeso;
  • Un thread può essere “bloccato” quando attende una risorsa;
  • Un thread può essere “terminato” in un qualunque momento, ovvero l’esecuzione viene immediatamente interrotta.

Priorità dei thread

Java assegna una priorità ai thread, che determina come deve essere considerato quel thread rispetto agli altri. Le priorità dei thread sono interi che specificano la priorità relativa di un thread in confronto ad un altro. La priorità di un thread viene utilizzata per decidere quando passare da un thread in esecuzione a quello successivo. Questa operazione è definita passaggio di contesto. Le regole che determinano quando si verifica questo passaggio di contesto sono semplici.

  • Un thread può volontariamente rinunciare al controllo, concedendo o bloccando esplicitamente l’I/O in attesa. In questo caso, tutti gli altri thread vengono esaminati e viene assegnato il tempo della CPU a quello con la priorità più alta.
  • Un thread può essere soppiantato da un thread con una priorità più alta a prescindere da ciò che stava eseguendo.

Il thread principale.

Quando un programma Java viene avviato, è già presente un thread in esecuzione, che viene solitamente definito thread principale del programma. Il thread principale è importante per due motivi:

  1. è il thread da cui gli altri thread “figli” verranno generati;
  2. deve essere l’ultimo thread a terminare l’esecuzione; quando il thread principale si ferma, il programma termina.

Creazione di un thread

Un thread può essere creato generando un’istanza di un oggetto di tipo Thread. Java definisce due metodi per portare a termine questa operazione:

  • è possibile implementare l’interfaccia Runnable;
  • è possibile estendere la classe Thread.

Il metodo più semplice per creare un thread è quello di creare una classe per implementare l’interfaccia Runnable, la quale estrae un’unità di codice eseguibile. È possibile costruire un thread su qualunque oggetto che implementa Runnable. Per implementare Runnable, una classe deve soltanto implementare un singolo metodo denominato run().

All’interno di run(), occorre definire il codice che costituisce il nuovo thread. run() stabilisce un punto di ingresso per un altro thread in esecuzione all’interno del programma.

Dopo aver creato una classe che implementa Runnable, è necessario creare un’istanza di un oggetto di tipo Thread dall’interno di quella classe. Thread definisce diversi costruttori. Il costruttore da noi utilizzato è stato:

Thread (Runnable threadOb, String NomeThread)

threadOb è l’istanza di una classe che implementa l’interfaccia Runnable (nel nostro caso abbiamo passato this), mentre NomeThread definisce il nome del thread creato. Dopo che è stato creato, il nuovo thread non potrà essere eseguito finchè non viene chiamato il metodo start(). start() esegue una chiamata al metodo run() della classe Runnable.

                                                                                Metodi principali della classe Thread

Metodo Significato
resume Riprende l’esecuzione di un thread sospeso
run Punto di entrata per il thread
sleep Sospende un thread per un determinato periodo di tempo
start Avvia un thread chiamando il relativo metodo di esecuzione
suspend Sospende un thread

Esempio di utilizzo dei thread nel codice

 public class Animazione extends Applet implements Runnable, MouseListener {

.

.

.

      public void start() {

      engine = new Thread(this);

      engine.start();

      showStatus(getAppletInfo());

      }

All’interno del costruttore new Thread() viene creato un nuovo oggetto Thread. Passando this come argomento, si indica che si desidera che il nuovo thread chiami il metodo run() su questo (this) oggetto (la classe Animazione implementa l’interfaccia Runnable). Poi viene chiamato start(), che avvia thread di esecuzione partendo dal metodo run() che visualizza l’animazione. Dopo aver chiamato start() il costruttore continua l’esecuzione del thread principale mostrando nella barra inferiore del browser le informazioni.

 

Classe thread vs interfaccia eseguibile:

      • Se estendiamo la classe Thread, la nostra classe non può estendere nessun’altra classe perché Java non supporta l’ereditarietà multipla. Ma, se implementiamo l’interfaccia Runnable, la nostra classe può comunque estendere altre classi base.
      • Possiamo ottenere le funzionalità di base di un thread estendendo la classe Thread perché fornisce alcuni metodi integrati come yield(), interrupt() ecc. che non sono disponibili nell’interfaccia Runnable.
      • L’uso di runnable ti darà un oggetto che può essere condiviso tra più thread.

 

Java è multithreading

  • Java consente l’esecuzione simultanea di due o più parti di un programma per il massimo utilizzo della CPU.
  • Ogni parte di tale programma è chiamata thread.
  • c’è un’applicazione e il codice di questa può essere eseguito in parallelo da ciascun thread. Il sistema operativo divide il tempo di elaborazione non solo tra le diverse applicazioni, ma anche tra ogni thread all’interno di un’applicazione.

Lascia un commento