Quelle est la différence entre les interfaces Callable et Runnable?

Runnable - c'est une interface fonctionnelle représentant une tâche pouvant être exécutée par un thread. Elle possède une méthode run(), qui ne prend pas d'arguments1 et ne retourne pas de valeur. Elle est utilisée pour exécuter des opérations en arrière-plan ne nécessitant pas de résultat.

Callable - c'est une interface paramétrée représentant également une tâche pouvant être exécutée par un thread. Elle possède une méthode call(), qui retourne un type générique <V> (une valeur arbitraire)2 et peut lancer une exception (Exception). Elle convient pour les tâches dont le résultat doit être utilisé.

Principales différences :

Caractéristique	Runnable	Callable
Valeur de retour	Non	Oui (type {@code <V>})
Exceptions	Non (méthode {@code run})	Oui (méthode {@code call})
Méthode	{@code void run()}	{@code V call() throws Exception}
Utilisation	{@code java.lang.Runnable}	{@code java.util.concurrent.Callable}

Exemple d'utilisation de Runnable :

// Implémentation de Runnable :
Runnable task = new Runnable() {
    @Override
    public void run() {
        // Effectue une opération sans retourner de résultat
        System.out.println("Runnable task executed");
    }
};

// Lancer dans un thread :
new Thread(task).start();

Exemple d'utilisation de Callable :

// Implémentation de Callable :
Callable<String> task = new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Effectue une opération et retourne un résultat :
        return "Callable task executed with result";
    }
};

// Lancer avec ExecutorService :
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(task);

try {
    // Obtenir le résultat :
    String result = future.get();
    System.out.println(result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
} finally {
    executor.shutdown();
}