Qual è la differenza tra le interfacce Callable e Runnable?

Runnable - è un'interfaccia funzionale che rappresenta un compito che può essere eseguito da un thread. Ha un metodo run(), che non accetta argomenti1 e non restituisce valori. Viene utilizzato per eseguire operazioni in background che non richiedono un risultato.

Callable - è un'interfaccia parametrizzata che rappresenta anch'essa un compito che può essere eseguito da un thread. Ha un metodo call(), che restituisce un tipo generico <V> (valore arbitrario)2 e può sollevare un'eccezione (Exception). È adatto per compiti il cui risultato deve essere utilizzato.

Principali differenze:

Caratteristica	Runnable	Callable
Valore di ritorno	No	Sì (tipo {@code <V>})
Eccezioni	No (metodo {@code run})	Sì (metodo {@code call})
Metodo	{@code void run()}	{@code V call() throws Exception}
Utilizzo	{@code java.lang.Runnable}	{@code java.util.concurrent.Callable}

Esempio di utilizzo di Runnable:

// Implementazione di Runnable:
Runnable task = new Runnable() {
    @Override
    public void run() {
        // Esegue qualche operazione senza restituzione di risultato
        System.out.println("Runnable task eseguito");
    }
};

// Esecuzione in un thread:
new Thread(task).start();

Esempio di utilizzo di Callable:

// Implementazione di Callable:
Callable<String> task = new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Esegue un'operazione e restituisce un risultato:
        return "Callable task eseguito con risultato";
    }
};

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

try {
    // Ottieni il risultato:
    String result = future.get();
    System.out.println(result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
} finally {
    executor.shutdown();
}