Hoe voer je asynchrone operaties uit in pure Android…

Er zijn verschillende manieren:

Threads (Draadjes): Het maken en beheren van eigen threads.

new Thread(new Runnable() {
    @Override
    public void run() {
        // Uitvoeren van een langdurige operatie
        // ...
        // UI bijwerken (vereist Handler)
        // handler.post(...)
    }
}).start();

Handler en Looper: Gebruikt voor het uitwisselen van berichten tussen threads, vaak om de UI bij te werken vanuit een achtergrondthread.

Handler handler = new Handler(Looper.getMainLooper());
// ... in een achtergrondthread
handler.post(new Runnable() {
    @Override
    public void run() {
        // UI bijwerken
    }
});

AsyncTask (verouderd, maar handig om te weten): Eenvoudige manier om asynchrone taken uit te voeren met UI-update. Niet aanbevolen voor nieuwe code.

private class MyAsyncTask extends AsyncTask<Void, Void, String> {
    @Override
    protected String doInBackground(Void... voids) {
        // Uitvoeren van een langdurige operatie
        return "Resultaat";
    }

    @Override
    protected void onPostExecute(String result) {
        // UI bijwerken met resultaat
    }
}
// ...
// new MyAsyncTask().execute();

ExecutorService en Future: Meer flexibel mechanisme voor het beheren van threadpools.

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Uitvoeren van een langdurige operatie
        return "Resultaat";
    }
});
// Resultaat ophalen (blokkerend)
// String result = future.get();

Kotlin Coroutines: Moderne aanpak voor asynchrone programmeren in Kotlin, gebaseerd op coroutines. Vereist het toevoegen van afhankelijkheden.

import kotlinx.coroutines.*

// ... in een coroutine scope (bijvoorbeeld, viewModelScope)
GlobalScope.launch(Dispatchers.IO) { // Uitvoering in achtergrond-IO thread
    // Uitvoeren van een langdurige operatie
    withContext(Dispatchers.Main) { // Overschakelen naar hoofdthread voor UI bijwerking
        // UI bijwerken
    }
}

De keuze van methode hangt af van de complexiteit van de taak, het vereiste controle niveau over threads en de taalvoorkeuren (Java/Kotlin). In moderne Android-ontwikkeling wordt aanbevolen Kotlin Coroutines of bibliotheken zoals RxJava of Flow te gebruiken voor asynchrone taken.

Hoe voer je asynchrone operaties uit in pure Android?