Wie führt man asynchrone Operationen in reinem…

Es können mehrere Methoden verwendet werden:

Thread: Erstellen eines neuen Threads zur Ausführung einer Aufgabe. Einfach, aber die Verwaltung des Lebenszyklus und die Rückgabe von Daten an den Hauptthread erfordern zusätzliche Logik (Handler, runOnUiThread).

new Thread(new Runnable() {
    @Override
    public void run() {
        // Asynchrone Operation ausführen
        // UI-Update über runOnUiThread oder Handler
    }
}).start();

AsyncTask: Veraltet, aber eine einfache Klasse zur Ausführung von Hintergrundaufgaben und UI-Aktualisierung. Bietet die Methoden onPreExecute, doInBackground, onProgressUpdate, onPostExecute.

private static class MyAsyncTask extends AsyncTask<Void, Void, String> {
    @Override
    protected String doInBackground(Void... voids) {
        // Asynchrone Operation ausführen
        return "Ergebnis";
    }

    @Override
    protected void onPostExecute(String result) {
        // UI im Hauptthread aktualisieren
    }
}

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

Handler und Looper: Flexibler Mechanismus zum Senden und Verarbeiten von Nachrichten und Aufgaben zwischen Threads. Handler ist mit dem Looper des Threads verbunden, in dem er erstellt wurde.

Handler handler = new Handler(Looper.getMainLooper()); // Für den Hauptthread

handler.post(new Runnable() {
    @Override
    public void run() {
        // Aufgabe im Hauptthread nach asynchroner Operation ausführen
    }
});

ExecutorService und Callable/Runnable: Standard-Java-Mechanismen zur Verwaltung eines Thread-Pools. Ermöglichen eine effizientere Ressourcennutzung und Steuerung der Ausführung mehrerer Aufgaben.

ExecutorService executor = Executors.newSingleThreadExecutor(); // Oder ein anderer Executor-Typ

executor.submit(new Runnable() {
    @Override
    public void run() {
        // Asynchrone Operation ausführen
    }
});

// Oder submit(Callable), um ein Ergebnis zu erhalten

Coroutine (mit Kotlin): Modernere und bequemere Methode zur Verwaltung asynchroner Operationen in Kotlin. Ermöglicht das Schreiben von asynchronem Code im imperativen Stil. Erfordert die Hinzufügung entsprechender Abhängigkeiten.

import kotlinx.coroutines.*

GlobalScope.launch(Dispatchers.IO) {
    // Asynchrone Operation im Hintergrund-Thread ausführen
    withContext(Dispatchers.Main) {
        // UI im Hauptthread aktualisieren
    }
}

Wie führt man asynchrone Operationen in reinem Android aus?