Wie führt man synchronen Code aus und erhält sein Ergebnis?

Sie können einen blockierenden Aufruf in einem separaten Thread verwenden, z.B. über Thread oder AsyncTask (obwohl letzteres veraltet ist).

// Beispiel mit Thread
fun performBlockingOperation(): String {
    // Simulation einer langen Operation
    Thread.sleep(2000)
    return "Ergebnis der synchronen Operation"
}

fun runSynchronousCode() {
    // Erstellen eines neuen Threads
    val thread = Thread {
        try {
            val result = performBlockingOperation()
            // Das Ergebnis kann an den Haupt-Thread zurückgegeben werden
            // via Handler oder runOnUiThread
            println("Erhaltenes Ergebnis: $result")
        } catch (e: Exception) {
            println("Fehler: ${e.message}")
        }
    }
    // Thread starten
    thread.start()

    // Wenn das Ergebnis im UI-Thread benötigt wird
    // Handler(Looper.getMainLooper()).post {
    //    // UI aktualisieren
    // }
}

Ein moderner alternativer Ansatz ist die Verwendung von Coroutinen mit blockierenden Dispatchern (obwohl dies möglicherweise nicht die beste Wahl für den UI-Thread ist).

import kotlinx.coroutines.*

suspend fun performBlockingCoroutineOperation(): String {
    // Simulation einer langen Operation
    delay(2000)
    return "Ergebnis der Coroutine in der Coroutine"
}

fun runBlockingCoroutine() {
    // Starten einer blockierenden Coroutine
    runBlocking {
        try {
            val result = performBlockingCoroutineOperation()
            println("Ergebnis aus der Coroutine: $result")
        } catch (e: Exception) {
            println("Fehler in der Coroutine: ${e.message}")
        }
    }
}

Es ist wichtig, blockierende Aufrufe im Haupt-UI-Thread zu vermeiden, um ANRs (Application Not Responding) zu verhindern.