Quels moyens du langage Java permettent de créer des…

Créer un thread en Java peut se faire de plusieurs façons :

Héritage de la classe Thread : Créez une nouvelle classe qui hérite de java.lang.Thread et surchargez la méthode run().

// Créer une classe qui hérite de Thread
class MyThread extends Thread {
    // Surchargez la méthode run
    @Override
    public void run() {
        // Code exécuté dans le nouveau thread
        System.out.println("Thread " + Thread.currentThread().getName() + " lancé.");
    }
}

Démarrage du thread :

// Créer une instance du thread
MyThread thread = new MyThread();
// Démarrer le thread
thread.start();

Implémentation de l'interface Runnable : Créez une classe qui implémente l'interface java.lang.Runnable et fournissez l'implémentation de la méthode run(). Ensuite, créez un objet Thread auquel vous passez l'objet Runnable.

// Créer une classe qui implémente Runnable
class MyRunnable implements Runnable {
    // Implémenter la méthode run
    @Override
    public void run() {
        // Code exécuté dans le nouveau thread
        System.out.println("Thread " + Thread.currentThread().getName() + " lancé.");
    }
}

Démarrage du thread :

// Créer une instance de Runnable
MyRunnable runnable = new MyRunnable();
// Créer un objet Thread en lui passant le Runnable
Thread thread = new Thread(runnable);
// Démarrer le thread
thread.start();

Cette méthode est préférée car elle permet à la classe d'hériter également d'autres classes.

Implémentation de l'interface Callable et utilisation de ExecutorService : L'interface java.util.concurrent.Callable, similaire à Runnable, représente une tâche pouvant s'exécuter dans un autre thread, mais contrairement à Runnable, la méthode call() peut renvoyer un résultat et lancer des exceptions. Pour exécuter un Callable, on utilise généralement des pools de threads de java.util.concurrent.ExecutorService.

import java.util.concurrent.*;

// Créer une classe qui implémente Callable
class MyCallable implements Callable<String> {
    // Implémenter la méthode call qui peut renvoyer un résultat
    @Override
    public String call() throws Exception {
        // Code exécuté dans le nouveau thread
        System.out.println("Thread " + Thread.currentThread().getName() + " lancé.");
        // Retourner le résultat
        return "Tâche terminée avec succès!";
    }
}

Démarrage et récupération du résultat :

import java.util.concurrent.*;

// Créer un pool de threads
ExecutorService executor = Executors.newFixedThreadPool(1);
// Créer une instance de Callable
MyCallable callable = new MyCallable();
// Soumettre la tâche pour exécution et obtenir un Future pour suivre le résultat
Future<String> future = executor.submit(callable);

try {
    // Récupérer le résultat de la tâche
    String result = future.get();
    System.out.println("Résultat : " + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
} finally {
    // Terminer le ExecutorService
    executor.shutdown();
}

Quels moyens du langage Java permettent de créer des threads?