Creazione di Thread Multipli in Java

Concetti Chiave
  • Creare e gestire più thread in Java consente di eseguire operazioni parallele, migliorando l'efficienza del programma.
  • Ogni thread può essere creato implementando l'interfaccia Runnable o estendendo la classe Thread.
  • I thread possono essere avviati utilizzando il metodo start(), che invoca il metodo run() del thread.
  • È possibile creare quanti più thread si desidera, a seconda delle esigenze del programma.

Creazione di Thread Multipli

Finora, abbiamo utilizzato solo due thread:

  1. il thread principale
  2. un thread figlio.

Tuttavia, il nostro programma può generare tutti i thread di cui ha bisogno.

Ad esempio, il seguente programma crea tre thread figli:

// Crea thread multipli.
class NuovoThread implements Runnable {

    // Nome del thread
    String nome;

    // Il thread effettivo
    Thread t;

    // Costruttore per creare un nuovo thread.
    public NuovoThread(String nomeThread) {
        nome = nomeThread;
        t = new Thread(this, nome);
        System.out.println("Nuovo thread: " + t);
    }

    // Questo è il punto di ingresso per il thread.
    public void run() {
        try {
            for(int i = 5; i > 0; i--) {
                System.out.println(nome + ": " + i);
                Thread.sleep(1000);
            }
        } catch (InterruptedException e) {
            System.out.println(nome + " Interrotto");
        }
        System.out.println(nome + " in uscita.");
    }

}

Di seguito è mostrato il programma principale che crea tre thread figli e li avvia:

class DemoThreadMultipli {

    // Questo è il punto di ingresso per il programma.
    // Il metodo main() crea tre thread figli.
    public static void main(String[] args) {
        NuovoThread nt1 = new NuovoThread("Uno");
        NuovoThread nt2 = new NuovoThread("Due");
        NuovoThread nt3 = new NuovoThread("Tre");
        // Avvia i thread.
        nt1.t.start();
        nt2.t.start();
        nt3.t.start();
        try {
            // aspetta che gli altri thread terminino
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            System.out.println("Thread principale Interrotto");
        }

        System.out.println("Thread principale in uscita.");
    }
}

Un esempio di output di questo programma è mostrato qui. (Il vostro output può variare in base all'ambiente di esecuzione specifico.)

Nuovo thread: Thread[Uno,5,main]
Nuovo thread: Thread[Due,5,main]
Nuovo thread: Thread[Tre,5,main]
Uno: 5
Due: 5
Tre: 5
Uno: 4
Due: 4
Tre: 4
Uno: 3
Tre: 3
Due: 3
Uno: 2
Tre: 2
Due: 2
Uno: 1
Tre: 1
Due: 1
Uno in uscita.
Due in uscita.
Tre in uscita.
Thread principale in uscita.

Come si può vedere, una volta avviati, tutti e tre i thread figli condividono la CPU. Si noti la chiamata a sleep(10000) in main().

Questo fa sì che il thread principale dorma per dieci secondi e garantisce che finisca per ultimo.