Hoe voer je synchronische code uit en krijg je het resultaat?

Je kunt een blokkerende oproep gebruiken in een aparte thread, bijvoorbeeld via Thread of AsyncTask (hoewel deze laatste verouderd is).

// Voorbeeld met Thread
fun performBlockingOperation(): String {
    // Simulatie van een lange operatie
    Thread.sleep(2000)
    return "Resultaat van de synchronisatie-operatie"
}

fun runSynchronousCode() {
    // Maak een nieuwe thread
    val thread = Thread {
        try {
            val result = performBlockingOperation()
            // Het resultaat kan worden teruggegeven aan de hoofdthread
            // via Handler of runOnUiThread
            println("Ontvangen resultaat: $result")
        } catch (e: Exception) {
            println("Fout: ${e.message}")
        }
    }
    // Start de thread
    thread.start()

    // Als je het resultaat in de UI-thread wilt krijgen
    // Handler(Looper.getMainLooper()).post {
    //    // UI bijwerken
    // }
}

Een moderne alternatieve aanpak is het gebruik van coroutines met blokkerende dispatchers (hoewel dit mogelijk niet de beste optie is voor de UI-thread).

import kotlinx.coroutines.*

suspend fun performBlockingCoroutineOperation(): String {
    // Simulatie van een lange operatie
    delay(2000)
    return "Resultaat van de coroutine"
}

fun runBlockingCoroutine() {
    // Start een blokkerende coroutine
    runBlocking {
        try {
            val result = performBlockingCoroutineOperation()
            println("Resultaat uit de coroutine: $result")
        } catch (e: Exception) {
            println("Fout in de coroutine: ${e.message}")
        }
    }
}

Het is belangrijk om blokkerende oproepen in de hoofd-UI-thread te vermijden om ANR (Application Not Responding) te voorkomen.