Qual é a diferença entre as interfaces Callable e Runnable?

Runnable - é uma interface funcional que representa uma tarefa que pode ser executada por uma thread. Possui um método run(), que não aceita argumentos1 e não retorna valores. É usado para executar operações em segundo plano que não requerem um resultado.

Callable - é uma interface parametrizada que também representa uma tarefa que pode ser executada por uma thread. Possui um método call(), que retorna um tipo genérico <V> (um valor arbitrário)2 e pode lançar uma exceção (Exception). É adequado para tarefas cujo resultado precisa ser utilizado.

Principais diferenças:

Característica	Runnable	Callable
Valor de retorno	Não	Sim (tipo {@code <V>})
Exceções	Não (método {@code run})	Sim (método {@code call})
Método	{@code void run()}	{@code V call() throws Exception}
Uso	{@code java.lang.Runnable}	{@code java.util.concurrent.Callable}

Exemplo de uso de Runnable:

// Implementação de Runnable:
Runnable task = new Runnable() {
    @Override
    public void run() {
        // Executa alguma operação sem devolver resultado
        System.out.println("Runnable task executed");
    }
};

// Executar em uma thread:
new Thread(task).start();

Exemplo de uso de Callable:

// Implementação de Callable:
Callable<String> task = new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Executa uma operação e devolve um resultado:
        return "Callable task executed with result";
    }
};

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

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