runBlocking — co to je, blokující most a jak funguje

Co je runBlocking?

runBlocking — je funkce Kotlinu, která vytváří nový CoroutineScope a spouští předanou korutinu, blokuje aktuální vlákno do jejího úplného dokončení. Na rozdíl od všech ostatních Coroutine Builder není runBlocking funkcí suspend a může být volán z běžného synchronního kódu. Signatura runBlocking přijímá CoroutineContext a suspend-blok a vrací výsledek typu T.

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

runBlocking spouští novou smyčku událostí (event-loop) v aktuálním vlákně. Když korutina zavolá funkci suspend (např. delay() nebo await()), runBlocking zablokuje vlákno a provádí další naplánované korutiny ve stejném vlákně, dokud není pozastavená obnovena. Toto je kooperativní blokování — vlákno není nečinné, ale zpracovává jiné korutiny.

Jak runBlocking funguje

Vnitřní mechanismus runBlocking je založen na event-loop: při volání funkce suspend runBlocking pozastaví provádění aktuálního bloku a spouští další korutiny z fronty. Po dokončení funkce suspend je provádění obnoveno. Tento cyklus pokračuje, dokud nejsou dokončeny všechny korutiny.

Event-loop pod kapotou

runBlocking používá vlastní jednovláknový fond pro provádění korutin. Na rozdíl od Dispatchers.IO nebo Default runBlocking nemění vlákna — zpracovává všechny korutiny v aktuálním vlákně, střídá jejich provádění. Toto je jediný builder, který zaručuje provádění ve stejném vlákně.

fun main() {
    val threadName = Thread.currentThread().getName()
    println("Před runBlocking na $threadName")

    val result = runBlocking {
        println("Uvnitř runBlocking na ${Thread.currentThread().getName()}")
        delay(500L)
        "Done"
    }

    println("Po runBlocking: $result")
}

Výstup ukáže, že všechny tři println se provádějí na jednom vlákně. runBlocking nemění vlákno, ale organizuje kooperativní multitasking v rámci jednoho vlákna pomocí event-loop.

Kdy použít runBlocking

runBlocking je opodstatněný ve třech scénářích: vstupní bod main() v konzolových aplikacích, jednotkové testy funkcí suspend a přemostění — volání kódu suspend z callbackových nebo blokujících knihoven. V produkčním kódu Android je použití na hlavním vlákně kategoricky zakázáno.

Pro Android testy používejte kotlinx-coroutines-test s TestDispatcher místo runBlocking. To poskytuje kontrolu nad časem, automatický reset a izolaci testů.

Alternativy k runBlocking

Ve většině scénářů lze a je třeba runBlocking nahradit asynchronními alternativami. Pro Android jsou to viewModelScope, lifecycleScope nebo CoroutineScope se správným dispečerem. Pro testy — TestCoroutineDispatcher a runTest.

    // Špatně: runBlocking na hlavním vlákně Android
runBlocking(Dispatchers.Main) {
    val result = networkApi.fetchData()
    textView.setText(result)
}

// Dobře: lifecycleScope
lifecycleScope.launch {
    val result = withContext(Dispatchers.IO) { networkApi.fetchData() }
    textView.setText(result)
}

Náhradou pro testy je runTest z kotlinx-coroutines-test. Vytváří TestCoroutineScope s virtuálním časem, což umožňuje testovat zpoždění bez reálného čekání. To testy zrychluje a činí je deterministickými.

Příklady použití runBlocking

Nejčastějším scénářem je testování funkcí suspend. runBlocking v testech umožňuje synchronně počkat na výsledek korutiny bez změny architektury. Druhým scénářem jsou knihovny s callback API, kde jsou funkce suspend volány z blokujícího kontextu přes runBlocking.

// Test suspend funkce s 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)
    }
}

Pro přemostění mezi callback a suspend světem používejte CompletableDeferred v kombinaci s runBlocking místo callbacků — to zjednodušuje řetězce asynchronních operací a zvyšuje čitelnost kódu.

Nebezpečí nesprávného použití

Nesprávné použití runBlocking je jednou z častých chyb při přechodu z blokujícího přístupu na korutiny. Hlavní problémy: volání na Main-Thread Android, vnořování runBlocking, použití uvnitř asynchronních funkcí a spouštění dlouhých operací přes runBlocking.

• ANR — runBlocking na Main-Thread Android blokuje vykreslování UI na více než 5 sekund
• Deadlock — vnořený runBlocking uvnitř korutiny na stejném vlákně vede k vzájemnému blokování
• Zmatek s dispečery — Dispatchers.Main uvnitř runBlocking v vlákně na pozadí nemá Looper a končí výjimkou
• Úniky paměti — runBlocking není automaticky zrušen při zničení Activity/Fragment

Zlaté pravidlo: runBlocking je most, nikoli náhrada. Používejte ho pouze pro propojení blokujícího a neblokujícího světa. Pro všechny ostatní úkoly používejte launch, async nebo lifecycleScope.