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

Awesome!

Completion rate improved to 3.33

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