Come creare un thread su Java che conta fino a 5

Testo

Crea un thread in Java che effettua un conteggio da uno a 5 e lo mostra in console. Non memorizzare la variabile che contiene il conteggio nel Main e nemmeno nella classe che definisce il thread.

Inoltre vi ricordiamo che, a fine pagina potete scaricare il file PDF ” su come creare un thread su java che conta fino a 5″ di questo esercizio gratuitamente. (anteprima in foto del file scaricabile).

Soluzione

Per risolvere il problema sono state istanziate tre classi:

• Main;
• MyThread;
• Utils.

La classe principale “Main” crea un istanza di un oggetto di tipo “MyThread”, che estende la classe “Thread”.

E poi esegue il metodo “start()” per far partire il thread. La classe “MyThread” ha un metodo “run()” che effettua un conteggio da 0 a 5 e stampa i risultati sulla console. La classe “Utils” ha una variabile statica “contatore” che viene utilizzata dal metodo “run()” per contare. Queste tre classi sono state utilizzate per creare un esempio di codice che utilizza un thread in Java.

Classe Main

Di seguito viene presentato il contenuto del file Main.java:

public class Main
{
    public static void main(String[] args) {
        System.out.println("Istanzio un thread");
        MyThread thread_counter = new MyThread();
        System.out.println("Lancio il thread");
        thread_counter.start(); //il metodo start chiama il metodo run
    }
}

Il codice che abbiamo qui rappresenta un esempio di come creare e utilizzare un thread in Java.

Un thread è una unità di esecuzione che viene utilizzata per eseguire un processo in parallelo con altri processi all’interno di un’applicazione.

La classe Main rappresenta il punto di partenza dell’applicazione, dove viene definito il metodo main che viene chiamato quando l’applicazione viene eseguita. In questo metodo viene prima di tutto istanziato un oggetto di tipo MyThread, che è una classe personalizzata che estende la classe Thread.

Successivamente, viene richiamato il metodo start sull’oggetto thread_counter, che fa partire l’esecuzione del thread. Il metodo start chiama il metodo run all’interno della classe MyThread, che contiene il codice che deve essere eseguito in parallelo al resto dell’applicazione.

Nel caso specifico, all’interno del metodo run è presente un ciclo for che esegue un conteggio da 1 a 5, e alla fine viene visualizzato il risultato a schermo.

Questo codice rappresenta una semplice dimostrazione di come utilizzare i thread in Java, e come essi possono essere utilizzati per eseguire operazioni in parallelo. Tuttavia, per un utilizzo più avanzato e professionale dei thread è consigliabile approfondire la conoscenza sulla programmazione multithread e sulle sue complessità.

Classe MyThread

Di seguito viene presentato il contenuto del file MyThread.java:

   
    //il pezzo di codice che viene lanciato in parallelo al principale
    public void run (){
        System.out.println("Ciao sono il thread");
        while (Utils.contatore < 5 ){
           System.out.println("La mia conta è arrivata fino a : " + Utils.contatore);
           Utils.contatore = Utils.contatore + 1;
        }
       //osservo le variabili
       System.out.println("Ho contato fino a : " + Utils.contatore);
    }
}

Questa classe “MyThread” estende la classe “Thread”, ovvero viene utilizzata come un thread parallelo alla classe principale “Main”. La classe contiene un metodo “run” che viene eseguito quando il thread viene lanciato con il metodo “start”. Il codice all’interno del metodo “run” effettua un conteggio da 0 a 5, stampando ad ogni iterazione la stringa “La mia conta è arrivata fino a : ” seguita dal valore corrente di una variabile statica “contatore”, che viene incrementata di 1 ad ogni iterazione.

Infine, viene stampato il valore finale della variabile “contatore” con la stringa “Ho contato fino a : “. La variabile “contatore” è dichiarata come statica all’interno della classe Utils, il che significa che ha una sola istanza condivisa tra tutte le istanze della classe “MyThread”. Questo è importante perché in questo modo ogni thread può accedere e modificare la variabile “contatore”, ma solo un thread alla volta, grazie alla sincronizzazione. In questo modo, ogni thread effettuerà un conteggio autonomo senza interferire con gli altri thread.

Classe Utils

Di seguito viene presentato il contenuto del file Utils.java:

   
 public class Utils{

    public static int contatore = 0;

}

Nel codice presente, vediamo che è presente anche una classe chiamata Utils che contiene una sola variabile, un intero contatore, che viene inizializzato a 0. Questa classe viene utilizzata come supporto alla classe MyThread per il conteggio da uno a 5, come possiamo vedere nella sua funzione run().

La classe MyThread estende la classe Thread, che ci permette di creare un nuovo thread che possa eseguire il codice parallelamente al thread principale. La classe MyThread definisce il metodo run(), che viene eseguito quando il thread viene lanciato. Il codice all’interno del metodo run() effettua il conteggio da uno a 5, incrementando la variabile contatore della classe Utils ad ogni iterazione, e visualizza a schermo la sua attuale valore, utilizzando il comando System.out.println().

Alla fine del ciclo while, viene visualizzato il valore finale di contatore, mostrando che la classe MyThread è riuscita a contare fino a 5. Questo è solo un esempio di base di come creare e utilizzare un thread in Java, ma la sua applicabilità può essere estesa a molte altre situazioni, come ad esempio per eseguire processi in parallelo per migliorare le prestazioni del programma.