¿Cuál es la diferencia entre las interfaces Callable y Runnable?

Runnable - es una interfaz funcional que representa una tarea que puede ser ejecutada por un hilo. Tiene un método run(), que no acepta argumentos1 y no devuelve valores. Se usa para realizar operaciones en segundo plano que no requieren un resultado.

Callable - es una interfaz parametrizada que también representa una tarea que puede ser ejecutada por un hilo. Tiene un método call(), que devuelve un tipo genérico <V> (un valor arbitrario)2 y puede lanzar una excepción (Exception). Es adecuado para tareas cuyo resultado necesita ser utilizado.

Diferencias principales:

Característica	Runnable	Callable
Valor de retorno	No	Sí (tipo {@code <V>})
Excepciones	No (método {@code run})	Sí (método {@code call})
Método	{@code void run()}	{@code V call() throws Exception}
Uso	{@code java.lang.Runnable}	{@code java.util.concurrent.Callable}

Ejemplo de uso de Runnable:

// Implementación de Runnable:
Runnable task = new Runnable() {
    @Override
    public void run() {
        // Ejecuta alguna operación sin devolver resultado
        System.out.println("Runnable task executed");
    }
};

// Ejecutar en un hilo:
new Thread(task).start();

Ejemplo de uso de Callable:

// Implementación de Callable:
Callable<String> task = new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Ejecuta una operación y devuelve un resultado:
        return "Callable task executed with result";
    }
};

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

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