Hoe start je asynchrone operaties in pure Android…

Verschillende methoden kunnen worden gebruikt:

Thread: Maak een nieuwe thread voor het uitvoeren van een taak. Eenvoudig, maar het beheren van de levenscyclus en het teruggeven van gegevens aan de hoofdthread vereist extra logica (Handler, runOnUiThread).

new Thread(new Runnable() {
    @Override
    public void run() {
        // Voer asynchrone operatie uit
        // UI bijwerken via runOnUiThread of Handler
    }
}).start();

AsyncTask: Verouderd, maar een eenvoudige klasse voor het uitvoeren van achtergrondtaken en het bijwerken van de UI. Biedt methoden onPreExecute, doInBackground, onProgressUpdate, onPostExecute.

private static class MyAsyncTask extends AsyncTask<Void, Void, String> {
    @Override
    protected String doInBackground(Void... voids) {
        // Voer asynchrone operatie uit
        return "Resultaat";
    }

    @Override
    protected void onPostExecute(String result) {
        // UI bijwerken op de hoofdthread
    }
}

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

Handler en Looper: Flexibeler mechanisme voor het verzenden en verwerken van berichten en taken tussen threads. Handler is gekoppeld aan de Looper van de thread waarin het is gemaakt.

Handler handler = new Handler(Looper.getMainLooper()); // Voor de hoofdthread

handler.post(new Runnable() {
    @Override
    public void run() {
        // Voer taak uit op de hoofdthread na asynchrone operatie
    }
});

ExecutorService en Callable/Runnable: Standaard Java-mechanismen voor het beheren van een threadpool. Ze maken efficiënter gebruik van bronnen en beheren de uitvoering van meerdere taken.

ExecutorService executor = Executors.newSingleThreadExecutor(); // Of een ander type executor

executor.submit(new Runnable() {
    @Override
    public void run() {
        // Voer asynchrone operatie uit
    }
});

// Of submit(Callable) voor het verkrijgen van een resultaat

Coroutine (met Kotlin): Modernere en handigere manier om asynchrone operaties te beheren in Kotlin. Ze maken het mogelijk om asynchrone code in een imperatieve stijl te schrijven. Vereist het toevoegen van de juiste afhankelijkheden.

import kotlinx.coroutines.*

GlobalScope.launch(Dispatchers.IO) {
    // Voer asynchrone operatie uit op achtergrondthread
    withContext(Dispatchers.Main) {
        // UI bijwerken op de hoofdthread
    }
}

Hoe start je asynchrone operaties in pure Android?