Wie führt man asynchrone Operationen in reinem…

Es gibt mehrere Möglichkeiten:

Threads (Fäden): Erstellen und Verwalten eigener Threads.

new Thread(new Runnable() {
    @Override
    public void run() {
        // Ausführen einer langwierigen Operation
        // ...
        // UI-Update (erfordert Handler)
        // handler.post(...)
    }
}).start();

Handler und Looper: Werden verwendet, um Nachrichten zwischen Threads auszutauschen, oft um die UI aus einem Hintergrund-Thread zu aktualisieren.

Handler handler = new Handler(Looper.getMainLooper());
// ... im Hintergrund-Thread
handler.post(new Runnable() {
    @Override
    public void run() {
        // UI aktualisieren
    }
});

AsyncTask (veraltet, aber nützlich zu wissen): Einfache Methode, um asynchrone Aufgaben mit UI-Update auszuführen. Nicht für neuen Code empfohlen.

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

    @Override
    protected void onPostExecute(String result) {
        // UI mit Ergebnis aktualisieren
    }
}
// ...
// new MyAsyncTask().execute();

ExecutorService und Future: Flexibler Mechanismus zur Verwaltung von Thread-Pools.

ExecutorService executor = Executors.newSingleThreadExecutor();
Future<String> future = executor.submit(new Callable<String>() {
    @Override
    public String call() throws Exception {
        // Ausführen einer langwierigen Operation
        return "Ergebnis";
    }
});
// Ergebnis abrufen (blockierend)
// String result = future.get();

Kotlin Coroutines: Moderner Ansatz für asynchrone Programmierung in Kotlin, basierend auf Koroutinen. Erfordert das Hinzufügen von Abhängigkeiten.

import kotlinx.coroutines.*

// ... im Coroutine-Scope (z.B. viewModelScope)
GlobalScope.launch(Dispatchers.IO) { // Ausführung im Hintergrund-IO-Thread
    // Ausführen einer langwierigen Operation
    withContext(Dispatchers.Main) { // Wechsel zum Haupt-Thread für UI-Update
        // UI aktualisieren
    }
}

Die Wahl der Methode hängt von der Komplexität der Aufgabe, dem erforderlichen Kontrollniveau über Threads und den Sprachpräferenzen (Java/Kotlin) ab. Für die moderne Android-Entwicklung wird empfohlen, Kotlin Coroutines oder Bibliotheken wie RxJava oder Flow für asynchrone Arbeit zu verwenden.

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