Come eseguire operazioni asincrone in Android puro…

Esistono diversi metodi:

Thread (Fili di esecuzione): Creazione e gestione di thread propri.

new Thread(new Runnable() {
    @Override
    public void run() {
        // Esecuzione di un'operazione lunga
        // ...
        // Aggiornamento dell'UI (richiede Handler)
        // handler.post(...)
    }
}).start();

Handler e Looper: Utilizzati per scambiare messaggi tra thread, spesso per aggiornare l'UI da un thread in background.

Handler handler = new Handler(Looper.getMainLooper());
// ... nel thread in background
handler.post(new Runnable() {
    @Override
    public void run() {
        // Aggiornamento dell'UI
    }
});

AsyncTask (obsoleto, ma utile da conoscere): Metodo semplice per eseguire compiti asincroni con aggiornamento dell'UI. Non raccomandato per nuovo codice.

private class MyAsyncTask extends AsyncTask<Void, Void, String> {
    @Override
    protected String doInBackground(Void... voids) {
        // Esecuzione di un'operazione lunga
        return "Risultato";
    }

    @Override
    protected void onPostExecute(String result) {
        // Aggiornamento dell'UI con il risultato
    }
}
// ...
// new MyAsyncTask().execute();

ExecutorService e Future: Meccanismo più flessibile per gestire pool di thread.

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Esecuzione di un'operazione lunga
        return "Risultato";
    }
});
// Ottenere il risultato (bloccante)
// String result = future.get();

Coroutines di Kotlin: Approccio moderno per la programmazione asincrona in Kotlin, basato su coroutine. Richiede l'aggiunta di dipendenze.

import kotlinx.coroutines.*

// ... nel scope di una coroutine (ad esempio, viewModelScope)
GlobalScope.launch(Dispatchers.IO) { // Esecuzione in thread di background IO
    // Esecuzione di un'operazione lunga
    withContext(Dispatchers.Main) { // Cambio al thread principale per aggiornare l'UI
        // Aggiornamento dell'UI
    }
}

La scelta del metodo dipende dalla complessità del compito, dal livello di controllo sui thread richiesto e dalle preferenze di linguaggio (Java/Kotlin). Nello sviluppo Android moderno, si consiglia di usare Kotlin Coroutines o librerie per il lavoro asincrono come RxJava o Flow.

Come eseguire operazioni asincrone in Android puro?