Care este diferența dintre interfețele Callable și Runnable?

Runnable - este o interfață funcțională care reprezintă o sarcină ce poate fi executată de un fir de execuție. Are o metodă run(), care nu acceptă argumente1 și nu returnează valori. Este utilizată pentru executarea operațiunilor de fundal care nu necesită rezultat.

Callable - este o interfață parametrizată care reprezintă, de asemenea, o sarcină ce poate fi executată de un fir de execuție. Are o metodă call(), care returnează un tip generic <V> (o valoare arbitrară)2 și poate arunca o excepție (Exception). Este potrivită pentru sarcini al căror rezultat trebuie utilizat.

Diferențele principale:

Caracteristică	Runnable	Callable
Valoare de întoarcere	Nu	Da (tip {@code <V>})
Excepții	Nu (metoda {@code run})	Da (metoda {@code call})
Metodă	{@code void run()}	{@code V call() throws Exception}
Utilizare	{@code java.lang.Runnable}	{@code java.util.concurrent.Callable}

Exemplu de utilizare a Runnable:

// Implementare Runnable:
Runnable task = new Runnable() {
    @Override
    public void run() {
        // Execută o operație fără a returna rezultat
        System.out.println("Sarcina Runnable executată");
    }
};

// Se pornește într-un fir:
new Thread(task).start();

Exemplu de utilizare a Callable:

// Implementare Callable:
Callable<String> task = new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Execută o operație și returnează un rezultat:
        return "Sarcina Callable executată cu rezultat";
    }
};

// Se rulează cu ExecutorService:
ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(task);

try {
    // Se obține rezultatul:
    String result = future.get();
    System.out.println(result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
} finally {
    executor.shutdown();
}