Esempio di Thread in Java

Benvenuti all’esempio di Thread Java. Processo e Thread sono due unità di esecuzione di base. La programmazione di concorrenza è più preoccupata dai thread java.

Processo

A process is a self contained execution environment and it can be seen as a program or application. However a program itself contains multiple processes inside it. Java runtime environment runs as a single process which contains different classes and programs as processes.

Thread

Il thread può essere chiamato processo leggero. Il thread richiede meno risorse per essere creato ed esiste nel processo, condividendo le risorse del processo.

Esempio di Thread Java

Ogni applicazione Java ha almeno un thread – il thread principale. Anche se ci sono molti altri thread Java in esecuzione in background, come la gestione della memoria, la gestione del sistema, l’elaborazione dei segnali, ecc., dal punto di vista dell’applicazione, il principale è il primo thread Java e possiamo crearne molti da esso. Il multithreading si riferisce all’esecuzione contemporanea di due o più thread in un singolo programma. Un processore single core del computer può eseguire solo un thread alla volta e il time slicing è la funzione del sistema operativo per condividere il tempo di processore tra diversi processi e thread.

Vantaggi del Thread Java

1. I thread Java sono leggeri rispetto ai processi, ci vuole meno tempo e risorse per crearne uno.
2. I thread condividono i dati e il codice del processo padre
3. Il cambio di contesto tra i thread è di solito meno costoso rispetto a quello tra i processi.
4. La comunicazione tra i thread è relativamente più semplice rispetto a quella tra i processi.

Java fornisce due modi per creare un thread programmaticamente.

1. Implementando l’interfaccia java.lang.Runnable.
2. Estendendo la classe java.lang.Thread.

Esempio di thread Java – implementazione dell’interfaccia Runnable

Per rendere una classe eseguibile, possiamo implementare l’interfaccia java.lang.Runnable e fornire l’implementazione nel metodo public void run(). Per utilizzare questa classe come Thread, è necessario creare un oggetto Thread passando l’oggetto di questa classe eseguibile e quindi chiamare il metodo start() per eseguire il metodo run() in un thread separato. Ecco un esempio di thread Java implementando l’interfaccia Runnable.

package com.journaldev.threads;

public class HeavyWorkRunnable implements Runnable {

    @Override
    public void run() {
        System.out.println("Doing heavy processing - START "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            //Ottenere la connessione al database, eliminare i dati non utilizzati dal database
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("Doing heavy processing - END "+Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }

}

Esempio di thread Java – estensione della classe Thread

Possiamo estendere la classe java.lang.Thread per creare la nostra classe thread Java personalizzata e sovrascrivere il metodo run(). Quindi possiamo creare un suo oggetto e chiamare il metodo start() per eseguire il metodo run della nostra classe thread Java personalizzata. Ecco un semplice esempio di thread Java che mostra come estendere la classe Thread.

package com.journaldev.threads;

public class MyThread extends Thread {

    public MyThread(String name) {
        super(name);
    }

    @Override
    public void run() {
        System.out.println("MyThread - START "+Thread.currentThread().getName());
        try {
            Thread.sleep(1000);
            //Ottenere la connessione al database, eliminare i dati non utilizzati dal database
            doDBProcessing();
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("MyThread - END "+Thread.currentThread().getName());
    }

    private void doDBProcessing() throws InterruptedException {
        Thread.sleep(5000);
    }
    
}

Ecco un programma di test che mostra come creare un thread Java ed eseguirlo.

package com.journaldev.threads;

public class ThreadRunExample {

    public static void main(String[] args){
        Thread t1 = new Thread(new HeavyWorkRunnable(), "t1");
        Thread t2 = new Thread(new HeavyWorkRunnable(), "t2");
        System.out.println("Starting Runnable threads");
        t1.start();
        t2.start();
        System.out.println("Runnable Threads has been started");
        Thread t3 = new MyThread("t3");
        Thread t4 = new MyThread("t4");
        System.out.println("Starting MyThreads");
        t3.start();
        t4.start();
        System.out.println("MyThreads has been started");
        
    }
}

L’output del programma di esempio di thread Java sopra è:

Starting Runnable threads
Runnable Threads has been started
Doing heavy processing - START t1
Doing heavy processing - START t2
Starting MyThreads
MyThread - START Thread-0
MyThreads has been started
MyThread - START Thread-1
Doing heavy processing - END t2
MyThread - END Thread-1
MyThread - END Thread-0
Doing heavy processing - END t1

Una volta avviato un qualsiasi thread, la sua esecuzione dipende dall’implementazione del time slicing del sistema operativo e non possiamo controllarne l’esecuzione. Tuttavia possiamo impostare la priorità dei thread ma anche in questo caso non è garantito che il thread con priorità più alta sarà eseguito per primo. Esegui più volte il programma sopra e noterai che non c’è un modello di inizio e fine dei thread.

Runnable vs Thread

Se la tua classe fornisce più funzionalità piuttosto che semplicemente eseguirsi come Thread, dovresti implementare l’interfaccia Runnable per fornire un modo per eseguirla come Thread. Se l’unico obiettivo della tua classe è di funzionare come Thread, puoi estendere la classe Thread. L’implementazione di Runnable è preferibile perché java supporta l’implementazione di molteplici interfacce. Se estendi la classe Thread, non puoi estendere nessun’altra classe. Consiglio: Come avrai notato, il thread non restituisce alcun valore ma cosa succede se vogliamo che il nostro thread esegua qualche elaborazione e poi restituisca il risultato al nostro programma client, controlla il nostro Java Callable Future. Aggiornamento: Da Java 8 in poi, Runnable è un’interfaccia funzionale e possiamo usare le espressioni lambda per fornire la sua implementazione piuttosto che utilizzare una classe anonima. Per ulteriori dettagli, consulta Java 8 Interfacce Funzionali.