Comment effectuer des opérations asynchrones dans…

Il existe plusieurs méthodes :

Threads (Fils d'exécution) : Création et gestion de threads propres.

new Thread(new Runnable() {
    @Override
    public void run() {
        // Exécution d'une opération longue
        // ...
        // Mise à jour de l'UI (nécessite Handler)
        // handler.post(...)
    }
}).start();

Handler et Looper : Utilisés pour échanger des messages entre threads, souvent pour mettre à jour l'UI depuis un thread en arrière-plan.

Handler handler = new Handler(Looper.getMainLooper());
// ... dans un thread en arrière-plan
handler.post(new Runnable() {
    @Override
    public void run() {
        // Mise à jour de l'UI
    }
});

AsyncTask (obsolète, mais utile à connaître) : Méthode simple pour exécuter des tâches asynchrones avec mise à jour de l'UI. Non recommandé pour le nouveau code.

private class MyAsyncTask extends AsyncTask<Void, Void, String> {
    @Override
    protected String doInBackground(Void... voids) {
        // Exécution d'une opération longue
        return "Résultat";
    }

    @Override
    protected void onPostExecute(String result) {
        // Mise à jour de l'UI avec le résultat
    }
}
// ...
// new MyAsyncTask().execute();

ExecutorService et Future : Mécanisme plus flexible pour gérer des pools de threads.

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Exécution d'une opération longue
        return "Résultat";
    }
});
// Obtenir le résultat (bloquant)
// String result = future.get();

Coroutines Kotlin : Approche moderne pour la programmation asynchrone en Kotlin, basée sur les coroutines. Nécessite l'ajout de dépendances.

import kotlinx.coroutines.*

// ... dans un scope de coroutine (par exemple, viewModelScope)
GlobalScope.launch(Dispatchers.IO) { // Exécution dans un thread de fond IO
    // Exécution d'une opération longue
    withContext(Dispatchers.Main) { // Passage au thread principal pour mettre à jour l'UI
        // Mise à jour de l'UI
    }
}

Le choix de la méthode dépend de la complexité de la tâche, du niveau de contrôle requis sur les threads et des préférences du langage (Java/Kotlin). Dans le développement Android moderne, il est recommandé d'utiliser les coroutines Kotlin ou des bibliothèques pour le travail asynchrone, telles que RxJava ou Flow.

Comment effectuer des opérations asynchrones dans Android pur?