Quais os meios da linguagem Java que podem ser usados…

Criar um thread em Java pode ser feito de várias maneiras:

Herança da classe Thread: Cria-se uma nova classe que herda de java.lang.Thread e sobrescreve o método run().

// Criar uma classe que herda de Thread
class MyThread extends Thread {
    // Sobrescrever o método run
    @Override
    public void run() {
        // Código que é executado no novo thread
        System.out.println("Thread " + Thread.currentThread().getName() + " iniciado.");
    }
}

Iniciar o thread:

// Criar uma instância do thread
MyThread thread = new MyThread();
// Iniciar a execução do thread
thread.start();

Implementação da interface Runnable: Cria-se uma classe que implementa a interface java.lang.Runnable e fornece a implementação do método run(). Depois, cria-se um objeto Thread ao qual se passa o objeto Runnable.

// Criar uma classe que implementa Runnable
class MyRunnable implements Runnable {
    // Implementar o método run
    @Override
    public void run() {
        // Código que é executado no novo thread
        System.out.println("Thread " + Thread.currentThread().getName() + " iniciado.");
    }
}

Iniciar o thread:

// Criar uma instância de Runnable
MyRunnable runnable = new MyRunnable();
// Criar um objeto Thread passando o Runnable
Thread thread = new Thread(runnable);
// Iniciar o thread
thread.start();

Este método é preferível, pois permite que a classe herde também de outras classes.

Implementação da interface Callable e uso de ExecutorService: A interface java.util.concurrent.Callable, semelhante a Runnable, representa uma tarefa que pode ser executada em outro thread, mas ao contrário de Runnable, o método call() pode retornar um resultado e lançar exceções. Para executar Callable, geralmente se usam pools de threads de java.util.concurrent.ExecutorService.

import java.util.concurrent.*;

// Criar uma classe que implementa Callable
class MyCallable implements Callable<String> {
    // Implementar o método call que pode retornar um resultado
    @Override
    public String call() throws Exception {
        // Código que é executado no novo thread
        System.out.println("Thread " + Thread.currentThread().getName() + " iniciado.");
        // Retornar resultado
        return "Tarefa concluída com sucesso!";
    }
}

Iniciar e obter o resultado:

import java.util.concurrent.*;

// Criar um pool de threads
ExecutorService executor = Executors.newFixedThreadPool(1);
// Criar uma instância de Callable
MyCallable callable = new MyCallable();
// Enviar a tarefa para execução e obter um Future para rastrear o resultado
Future<String> future = executor.submit(callable);

try {
    // Obter o resultado da tarefa
    String result = future.get();
    System.out.println("Resultado: " + result);
} catch (InterruptedException | ExecutionException e) {
    e.printStackTrace();
} finally {
    // Encerrar o ExecutorService
    executor.shutdown();
}

Quais os meios da linguagem Java que podem ser usados para criar threads?