Wat is het verschil tussen de interfaces Callable en Runnable?

Runnable - is een functionele interface die een taak vertegenwoordigt die door een thread kan worden uitgevoerd. Het heeft een methode run(), die geen argumenten accepteert1 en geen waarden retourneert. Wordt gebruikt voor het uitvoeren van achtergrondbewerkingen die geen resultaat vereisen.

Callable - is een parametriseerde interface die ook een taak vertegenwoordigt die door een thread kan worden uitgevoerd. Het heeft een methode call(), die een generiek type <V> (een willekeurige waarde)2 retourneert en een uitzondering (Exception) kan werpen. Geschikt voor taken waarvan het resultaat moet worden gebruikt.

Belangrijkste verschillen:

Kenmerk	Runnable	Callable
Retourwaarde	Nee	Ja (type {@code <V>})
Uitzonderingen	Nee (methode {@code run})	Ja (methode {@code call})
Methode	{@code void run()}	{@code V call() throws Exception}
Gebruik	{@code java.lang.Runnable}	{@code java.util.concurrent.Callable}

Voorbeeld van gebruik van Runnable:

// Implementatie van Runnable:
Runnable task = new Runnable() {
    @Override
    public void run() {
        // Voert een operatie uit zonder resultaat
        System.out.println("Runnable taak uitgevoerd");
    }
};

// Uitvoeren in een thread:
new Thread(task).start();

Voorbeeld van gebruik van Callable:

// Implementatie van Callable:
Callable<String> task = new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Voert een operatie uit en geeft een resultaat terug:
        return "Callable taak uitgevoerd met resultaat";
    }
};

// Uitvoeren met behulp van ExecutorService:
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(task);

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