Ad esempio, si immagini che il programma abbia un thread principale responsabile della visualizzazione dell'interfaccia utente. Allo stesso tempo, è possibile creare un ulteriore thread per caricare dati dalla rete o eseguire calcoli complessi. Questo contribuisce a rendere il programma più reattivo ed efficiente.

Dichiarazione di un Thread in Java

Con la classe Thread: è possibile creare una sottoclasse della classe Thread e sovrascrivere il metodo run() , che contiene il codice che verrà eseguito nel nuovo thread.

Main.java


              123456789
            
// Create a new thread using an anonymous subclass of `Thread`
Thread thread = new Thread() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Start the thread execution
thread.start();

Utilizzo dell'interfaccia Runnable

Con l'interfaccia Runnable, è possibile implementare l'interfaccia Runnable, fornire un metodo run() e passarla al costruttore della classe Thread.

Main.java


              123456789101112
            
// Create a new `Runnable` instance with an anonymous class implementing the run method
Runnable runnable = new Runnable() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Create a new `Thread` instance, passing the `Runnable` as argument
Thread thread = new Thread(runnable);

// Start the thread execution
thread.start();

Ereditarietà della classe Thread

In alternativa, è possibile ereditare la classe Thread e sovrascrivere il metodo run().

Main.java


              123456789
            
// The `MyThread` class extends the `Thread` class to create a custom thread
public class MyThread extends Thread {

    // The run method is overridden to define the task that the thread will execute
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}

Implementazione dell'interfaccia Runnable

È possibile implementare l'interfaccia Runnable e al suo interno definire il metodo run():

Main.java


              123456789
            
// The `MyThread` class implements the `Runnable` interface to create a custom task
public class MyThread implements Runnable {

    // The run method is overridden to define the task that will be executed when the thread runs
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}

Nota

Il metodo run() in un thread Java consente l'esecuzione di codice in un thread separato, inclusi compiti come l'elaborazione di dati, calcoli, download di file e invio o ricezione di dati tramite rete.

Differenza tra Thread e Runnable

In Java, un Thread è un canale speciale che consente l'esecuzione concorrente di compiti, permettendo al programma di svolgere operazioni in un thread separato, come calcoli o processi di lunga durata come il caricamento dei dati.

L'interfaccia Runnable, con il suo unico metodo run(), definisce un compito da eseguire da un thread. È possibile passare un'implementazione di Runnable al costruttore di un Thread per eseguire il compito in un nuovo thread. Questo metodo facilita la gestione e l'esecuzione efficiente di compiti paralleli.

Metodi disponibili per i thread in Java

Avvio di un thread utilizzando il metodo start(), che indica che il codice deve essere eseguito in un nuovo thread. Questo significa che il thread principale continua a eseguire il proprio codice e non attende il completamento del thread appena avviato.

Main.java


              1234567891011121314151617181920212223242526
            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a new thread that will sleep for 5 seconds
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(5000); // Simulate work by sleeping for 5 seconds
            } catch (InterruptedException e) {
                throw new RuntimeException(e); // Handle interruption by rethrowing as a runtime exception
            }
        });

        // Start the thread
        thread.start();

        // Check if the thread is alive before calling `join()`
        System.out.println("Is the thread alive before the join() method: " + thread.isAlive());

        // Wait for the thread to finish execution
        thread.join();

        // Check if the thread is alive after `join()`
        System.out.println("Is the thread alive after join(): " + thread.isAlive());
    }
}

Abbiamo anche un metodo che permette al thread principale di attendere il completamento dell'esecuzione del thread che ha avviato, utilizzando il metodo join(). Questo metodo attende fino a quando il thread non è completamente eseguito. È possibile verificare se il thread è attualmente in esecuzione utilizzando il metodo isAlive().

Il codice Thread.sleep(5000) mette in pausa il thread per 5000 millisecondi (5 secondi).

try {
    Thread.sleep(5000); // Simulate work by sleeping for 5 seconds
} catch (InterruptedException e) {
    throw new RuntimeException(e); // Handle interruption by rethrowing as a runtime exception
}

Nell'esempio, prima della chiamata a join(), il thread era in esecuzione. Dopo la chiamata a join(), non lo è più, perché join() indica che si attende in quel punto fino al termine dell'esecuzione del thread.

Se si desidera fermare un thread, è possibile utilizzare il metodo interrupt(). Tuttavia, affinché funzioni, è necessario verificare se il thread che si sta interrompendo è stato interrotto.

Main.java


              123456789101112131415161718192021222324252627282930313233
            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a thread that will perform some task
        Thread thread = new Thread(() -> {
            // Loop runs until the thread is interrupted
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running...");

                // Simulate some work with a delay
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Thread was interrupted during sleep.");
                    // Re-interrupt the thread to ensure the loop exits
                    Thread.currentThread().interrupt();
                }
            }

            System.out.println("Thread is exiting...");
        });

        // Start the thread
        thread.start();

        // Let the thread run for a bit
        Thread.sleep(3000);

        // Interrupt the thread
        thread.interrupt();
    }
}

Questo esempio crea un thread che esegue un'attività in un ciclo finché non viene interrotto. Quando il thread viene interrotto mentre è in attesa (sleeping), viene generata un'eccezione, gestita impostando il flag di interruzione, e quindi il thread termina.

Senza un gestore di eccezione InterruptedException nel thread, il thread non verrebbe interrotto.

Nota

Questi metodi consentono di gestire il ciclo di vita e l'esecuzione dei thread in Java, offrendo flessibilità e controllo sulle applicazioni multithread. Nei prossimi capitoli, approfondiremo ulteriormente questi metodi.

1. Che cos'è un thread in Java?

2. Qual è la differenza tra la classe Thread e l'interfaccia Runnable in Java?

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 3

Chieda ad AI

Chieda pure quello che desidera o provi una delle domande suggerite per iniziare la nostra conversazione

Scorri per mostrare il menu

Dichiarazione di un Thread in Java

Con la classe Thread: è possibile creare una sottoclasse della classe Thread e sovrascrivere il metodo run() , che contiene il codice che verrà eseguito nel nuovo thread.

Main.java


              123456789
            
// Create a new thread using an anonymous subclass of `Thread`
Thread thread = new Thread() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Start the thread execution
thread.start();

Utilizzo dell'interfaccia Runnable

Con l'interfaccia Runnable, è possibile implementare l'interfaccia Runnable, fornire un metodo run() e passarla al costruttore della classe Thread.

Main.java


              123456789101112
            
// Create a new `Runnable` instance with an anonymous class implementing the run method
Runnable runnable = new Runnable() {
    public void run() {
        // Code that will execute in the new thread
    }
};

// Create a new `Thread` instance, passing the `Runnable` as argument
Thread thread = new Thread(runnable);

// Start the thread execution
thread.start();

Ereditarietà della classe Thread

In alternativa, è possibile ereditare la classe Thread e sovrascrivere il metodo run().

Main.java


              123456789
            
// The `MyThread` class extends the `Thread` class to create a custom thread
public class MyThread extends Thread {

    // The run method is overridden to define the task that the thread will execute
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}

Implementazione dell'interfaccia Runnable

È possibile implementare l'interfaccia Runnable e al suo interno definire il metodo run():

Main.java


              123456789
            
// The `MyThread` class implements the `Runnable` interface to create a custom task
public class MyThread implements Runnable {

    // The run method is overridden to define the task that will be executed when the thread runs
    @Override
    public void run() {
        // Code to be executed by the thread should go here
    }
}

Nota

Differenza tra Thread e Runnable

Metodi disponibili per i thread in Java

Main.java


              1234567891011121314151617181920212223242526
            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a new thread that will sleep for 5 seconds
        Thread thread = new Thread(() -> {
            try {
                Thread.sleep(5000); // Simulate work by sleeping for 5 seconds
            } catch (InterruptedException e) {
                throw new RuntimeException(e); // Handle interruption by rethrowing as a runtime exception
            }
        });

        // Start the thread
        thread.start();

        // Check if the thread is alive before calling `join()`
        System.out.println("Is the thread alive before the join() method: " + thread.isAlive());

        // Wait for the thread to finish execution
        thread.join();

        // Check if the thread is alive after `join()`
        System.out.println("Is the thread alive after join(): " + thread.isAlive());
    }
}

Il codice Thread.sleep(5000) mette in pausa il thread per 5000 millisecondi (5 secondi).

try {
    Thread.sleep(5000); // Simulate work by sleeping for 5 seconds
} catch (InterruptedException e) {
    throw new RuntimeException(e); // Handle interruption by rethrowing as a runtime exception
}

Main.java


              123456789101112131415161718192021222324252627282930313233
            
package com.example;

public class Main {
    public static void main(String[] args) throws InterruptedException {
        // Create a thread that will perform some task
        Thread thread = new Thread(() -> {
            // Loop runs until the thread is interrupted
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Thread is running...");

                // Simulate some work with a delay
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    System.out.println("Thread was interrupted during sleep.");
                    // Re-interrupt the thread to ensure the loop exits
                    Thread.currentThread().interrupt();
                }
            }

            System.out.println("Thread is exiting...");
        });

        // Start the thread
        thread.start();

        // Let the thread run for a bit
        Thread.sleep(3000);

        // Interrupt the thread
        thread.interrupt();
    }
}

Senza un gestore di eccezione InterruptedException nel thread, il thread non verrebbe interrotto.

Nota

1. Che cos'è un thread in Java?

2. Qual è la differenza tra la classe Thread e l'interfaccia Runnable in Java?

Tutto è chiaro?

Grazie per i tuoi commenti!

Sezione 1. Capitolo 3