Como iniciar operações assíncronas no Android puro…

Podem ser utilizados vários métodos:

Thread: Criar uma nova thread para executar uma tarefa. Simples, mas a gestão do ciclo de vida e a passagem de dados de volta para a thread principal requer lógica adicional (Handler, runOnUiThread).

new Thread(new Runnable() {
    @Override
    public void run() {
        // Executar operação assíncrona
        // Atualizar a UI via runOnUiThread ou Handler
    }
}).start();

AsyncTask: Obsoleto, mas uma classe simples para executar operações em segundo plano e atualizar a UI. Fornece métodos onPreExecute, doInBackground, onProgressUpdate, onPostExecute.

private static class MyAsyncTask extends AsyncTask<Void, Void, String> {
    @Override
    protected String doInBackground(Void... voids) {
        // Executar operação assíncrona
        return "Resultado";
    }

    @Override
    protected void onPostExecute(String result) {
        // Atualizar a UI no thread principal
    }
}

// Executar: new MyAsyncTask().execute();

Handler e Looper: Mecanismo mais flexível para enviar e processar mensagens e tarefas entre threads. Handler está associado ao Looper do thread onde é criado.

Handler handler = new Handler(Looper.getMainLooper()); // Para o thread principal

handler.post(new Runnable() {
    @Override
    public void run() {
        // Executar tarefa no thread principal após operação assíncrona
    }
});

ExecutorService e Callable/Runnable: Mecanismos padrão do Java para gerir um grupo de threads. Permitem usar os recursos de forma mais eficiente e gerir a execução de múltiplas tarefas.

ExecutorService executor = Executors.newSingleThreadExecutor(); // Ou outro tipo de executor

executor.submit(new Runnable() {
    @Override
    public void run() {
        // Executar operação assíncrona
    }
});

// Ou submit(Callable) para obter um resultado

Coroutine (com Kotlin): Forma mais moderna e confortável de gerir operações assíncronas em Kotlin. Permitem escrever código assíncrono em estilo imperativo. Requer adição de dependências correspondentes.

import kotlinx.coroutines.*

GlobalScope.launch(Dispatchers.IO) {
    // Executar operação assíncrona em thread de fundo
    withContext(Dispatchers.Main) {
        // Atualizar a UI na thread principal
    }
}

Como iniciar operações assíncronas no Android puro?