runBlocking — apa itu, jembatan pemblokir dan cara kerjanya

Apa itu runBlocking?

runBlocking — fungsi Kotlin yang membuat CoroutineScope baru dan menjalankan coroutine yang diberikan, memblokir thread saat ini hingga selesai sepenuhnya. Tidak seperti semua Coroutine Builder lainnya, runBlocking bukan fungsi suspend dan dapat dipanggil dari kode synchronous biasa. Signature runBlocking menerima CoroutineContext dan blok suspend, mengembalikan hasil bertipe T.

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

runBlocking memulai event-loop baru di thread saat ini. Ketika coroutine memanggil fungsi suspend (misalnya delay() atau await()), runBlocking memblokir thread dan menjalankan coroutine lain yang dijadwalkan di thread yang sama hingga yang ditangguhkan dilanjutkan. Ini adalah pemblokiran kooperatif — thread tidak diam, tetapi memproses coroutine lain.

Cara kerja runBlocking

Mekanisme internal runBlocking didasarkan pada event-loop: saat memanggil fungsi suspend, runBlocking menangguhkan eksekusi blok saat ini dan menjalankan coroutine lain dari antrian. Ketika fungsi suspend selesai, eksekusi dilanjutkan. Siklus ini berlanjut hingga semua coroutine selesai.

Event-loop di balik layar

runBlocking menggunakan pool single-thread miliknya sendiri untuk mengeksekusi coroutine. Tidak seperti Dispatchers.IO atau Default, runBlocking tidak mengganti thread — ia memproses semua coroutine di thread saat ini, menyelingi eksekusinya. Ini adalah satu-satunya builder yang menjamin eksekusi di thread yang sama.

fun main() {
    val threadName = Thread.currentThread().getName()
    println("Sebelum runBlocking di $threadName")

    val result = runBlocking {
        println("Di dalam runBlocking di ${Thread.currentThread().getName()}")
        delay(500L)
        "Done"
    }

    println("Setelah runBlocking: $result")
}

Hasilnya akan menunjukkan bahwa ketiga println dieksekusi pada satu thread. runBlocking tidak mengganti thread, tetapi mengatur multitasking kooperatif dalam satu thread melalui event-loop.

Kapan menggunakan runBlocking

runBlocking dibenarkan dalam tiga skenario: titik masuk main() di aplikasi konsol, pengujian unit fungsi suspend, dan jembatan — memanggil kode suspend dari library berbasis callback atau blocking. Dalam kode produksi Android, penggunaan di thread utama sangat dilarang.

Untuk pengujian Android gunakan kotlinx-coroutines-test dengan TestDispatcher sebagai pengganti runBlocking. Ini memberikan kontrol atas waktu, reset otomatis, dan isolasi pengujian.

Alternatif runBlocking

Di sebagian besar skenario, runBlocking dapat dan harus diganti dengan alternatif asynchronous. Untuk Android, ini adalah viewModelScope, lifecycleScope, atau CoroutineScope dengan dispatcher yang tepat. Untuk pengujian — TestCoroutineDispatcher dan runTest.

    // Buruk: runBlocking di thread utama Android
runBlocking(Dispatchers.Main) {
    val result = networkApi.fetchData()
    textView.setText(result)
}

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

Pengganti untuk pengujian adalah runTest dari kotlinx-coroutines-test. Ini membuat TestCoroutineScope dengan waktu virtual, memungkinkan pengujian penundaan tanpa menunggu nyata. Ini mempercepat pengujian dan membuatnya deterministik.

Contoh penggunaan runBlocking

Skenario paling umum — menguji fungsi suspend. runBlocking dalam pengujian memungkinkan menunggu hasil coroutine secara synchronous tanpa mengubah arsitektur. Skenario kedua — library dengan callback API, di mana fungsi suspend dipanggil dari konteks blocking melalui runBlocking.

// Uji fungsi suspend dengan 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)
    }
}

Untuk menjembatani dunia callback dan suspend, gunakan CompletableDeferred dalam kombinasi dengan runBlocking sebagai pengganti callback — ini menyederhanakan rantai operasi asynchronous dan meningkatkan keterbacaan kode.

Bahaya penggunaan yang salah

Penggunaan runBlocking yang salah adalah salah satu kesalahan umum saat beralih dari pendekatan blocking ke coroutine. Masalah utama: pemanggilan di Main-Thread Android, penyarangan runBlocking, penggunaan di dalam fungsi asynchronous, dan menjalankan operasi panjang melalui runBlocking.

• ANR — runBlocking di Main-Thread Android memblokir rendering UI lebih dari 5 detik
• Deadlock — runBlocking bersarang di dalam coroutine pada thread yang sama menyebabkan kebuntuan timbal balik
• Kebingungan dengan dispatcher — Dispatchers.Main di dalam runBlocking di thread latar belakang tidak memiliki Looper dan gagal dengan exception
• Kebocoran memori — runBlocking tidak dibatalkan secara otomatis saat Activity/Fragment dihancurkan

Aturan emas: runBlocking adalah jembatan, bukan pengganti. Gunakan hanya untuk menghubungkan dunia blocking dan non-blocking. Untuk semua tugas lain, gunakan launch, async, atau lifecycleScope.