runBlocking — τι είναι, μπλοκαριστική γέφυρα και πώς λειτουργεί

Τι είναι το runBlocking;

runBlocking — είναι μια συνάρτηση Kotlin που δημιουργεί ένα νέο CoroutineScope και εκτελεί το coroutine που του μεταβιβάζεται, μπλοκάροντας το τρέχον νήμα μέχρι την πλήρη ολοκλήρωσή του. Σε αντίθεση με όλους τους άλλους Coroutine Builder, το runBlocking δεν είναι συνάρτηση suspend και μπορεί να κληθεί από συνηθισμένο σύγχρονο κώδικα. Η υπογραφή του runBlocking δέχεται ένα CoroutineContext και ένα suspend-block, επιστρέφοντας αποτέλεσμα τύπου T.

public fun <T> runBlocking(
    context: CoroutineContext = EmptyCoroutineContext,
    block: suspend CoroutineScope.() -> T
): T

Το runBlocking εκκινεί έναν νέο βρόχο γεγονότων (event-loop) στο τρέχον νήμα. Όταν το coroutine καλεί μια συνάρτηση suspend (π.χ. delay() ή await()), το runBlocking μπλοκάρει το νήμα και εκτελεί άλλα προγραμματισμένα coroutine στο ίδιο νήμα μέχρι να συνεχιστεί το ανεσταλμένο. Αυτό είναι συνεργατικό μπλοκάρισμα — το νήμα δεν μένει αδρανές, αλλά επεξεργάζεται άλλα coroutine.

Πώς λειτουργεί το runBlocking

Ο εσωτερικός μηχανισμός του runBlocking βασίζεται σε event-loop: όταν καλείται μια συνάρτηση suspend, το runBlocking αναστέλλει την εκτέλεση του τρέχοντος μπλοκ και εκτελεί άλλα coroutine από την ουρά. Όταν η συνάρτηση suspend ολοκληρωθεί, η εκτέλεση συνεχίζεται. Αυτός ο κύκλος συνεχίζεται μέχρι να ολοκληρωθούν όλα τα coroutine.

Event-loop κάτω από το καπό

Το runBlocking χρησιμοποιεί το δικό του μονονηματικό pool για την εκτέλεση coroutine. Σε αντίθεση με τα Dispatchers.IO ή Default, το runBlocking δεν αλλάζει νήματα — επεξεργάζεται όλα τα coroutine στο τρέχον νήμα, εναλλάσσοντας την εκτέλεσή τους. Αυτός είναι ο μοναδικός builder που εγγυάται την εκτέλεση στο ίδιο νήμα.

fun main() {
    val threadName = Thread.currentThread().getName()
    println("Πριν το runBlocking στο $threadName")

    val result = runBlocking {
        println("Μέσα στο runBlocking στο ${Thread.currentThread().getName()}")
        delay(500L)
        "Done"
    }

    println("Μετά το runBlocking: $result")
}

Η έξοδος θα δείξει ότι και τα τρία println εκτελούνται σε ένα νήμα. Το runBlocking δεν αλλάζει νήμα, αλλά οργανώνει συνεργατική πολυδιεργασία μέσα σε ένα νήμα μέσω event-loop.

Πότε να χρησιμοποιείτε το runBlocking

Το runBlocking δικαιολογείται σε τρία σενάρια: το σημείο εισόδου main() σε εφαρμογές κονσόλας, δοκιμές μονάδας συναρτήσεων suspend και γεφύρωμα — κλήση κώδικα suspend από βιβλιοθήκες βασισμένες σε callback ή blocking. Σε production κώδικα Android, η χρήση στο κύριο νήμα απαγορεύεται αυστηρά.

Για δοκιμές Android χρησιμοποιήστε kotlinx-coroutines-test με TestDispatcher αντί του runBlocking. Αυτό παρέχει έλεγχο του χρόνου, αυτόματη επαναφορά και απομόνωση δοκιμών.

Εναλλακτικές του runBlocking

Στα περισσότερα σενάρια, το runBlocking μπορεί και πρέπει να αντικατασταθεί με ασύγχρονες εναλλακτικές. Για Android, αυτές είναι τα viewModelScope, lifecycleScope ή CoroutineScope με τον κατάλληλο dispatcher. Για δοκιμές — TestCoroutineDispatcher και runTest.

    // Κακό: runBlocking στο κύριο νήμα Android
runBlocking(Dispatchers.Main) {
    val result = networkApi.fetchData()
    textView.setText(result)
}

// Καλό: lifecycleScope
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) { networkApi.fetchData() }
    textView.setText(result)
}

Η αντικατάσταση για δοκιμές είναι το runTest από το kotlinx-coroutines-test. Δημιουργεί ένα TestCoroutineScope με εικονικό χρόνο, επιτρέποντας τη δοκιμή καθυστερήσεων χωρίς πραγματική αναμονή. Αυτό επιταχύνει τις δοκιμές και τις καθιστά ντετερμινιστικές.

Παραδείγματα χρήσης runBlocking

Το πιο συνηθισμένο σενάριο — δοκιμή συναρτήσεων suspend. Το runBlocking σε δοκιμές επιτρέπει τη σύγχρονη αναμονή για το αποτέλεσμα του coroutine χωρίς αλλαγή της αρχιτεκτονικής. Το δεύτερο σενάριο — βιβλιοθήκες με callback API, όπου οι συναρτήσεις suspend καλούνται από blocking περιβάλλον μέσω runBlocking.

// Δοκιμή suspend συνάρτησης με runBlocking
class RepositoryTest {
    @Test
    fun `fetchUser returns correct data`() {
        val repository = UserRepository(FakeApi())

        val result = runBlocking {
            repository.fetchUser("123")
        }

        assertEquals("John", result.name)
        assertEquals("john@test.com", result.email)
    }
}

Για γεφύρωμα μεταξύ του κόσμου callback και suspend, χρησιμοποιήστε CompletableDeferred σε συνδυασμό με runBlocking αντί για callbacks — αυτό απλοποιεί τις αλυσίδες ασύγχρονων λειτουργιών και βελτιώνει την αναγνωσιμότητα του κώδικα.

Κίνδυνοι λανθασμένης χρήσης

Η λανθασμένη χρήση του runBlocking είναι ένα από τα συνηθισμένα λάθη κατά τη μετάβαση από την προσέγγιση blocking στα coroutine. Κύρια προβλήματα: κλήση στο Main-Thread Android, ένθεση του runBlocking, χρήση εντός ασύγχρονων συναρτήσεων και εκτέλεση μακροχρόνιων λειτουργιών μέσω runBlocking.

• ANR — το runBlocking στο Main-Thread Android μπλοκάρει την απόδοση UI για περισσότερο από 5 δευτερόλεπτα
• Deadlock — το ένθετο runBlocking μέσα σε coroutine στο ίδιο νήμα οδηγεί σε αμοιβαίο μπλοκάρισμα
• Σύγχυση με τους dispatcher — το Dispatchers.Main μέσα σε runBlocking σε νήμα παρασκηνίου δεν έχει Looper και αποτυγχάνει με εξαίρεση
• Διαρροή μνήμης — το runBlocking δεν ακυρώνεται αυτόματα κατά την καταστροφή του Activity/Fragment

Χρυσός κανόνας: το runBlocking είναι μια γέφυρα, όχι αντικατάσταση. Χρησιμοποιήστε το μόνο για τη σύνδεση blocking και non-blocking κόσμων. Για όλες τις άλλες εργασίες, εφαρμόστε launch, async ή lifecycleScope.