Dispatchers — mga pangunahing konsepto, mga uri ng dispatcher at kung paano gumagana ang mga ito

Ano ang Dispatchers?

Dispatchers — mga implementasyon ng interface ng CoroutineDispatcher, na mga elemento ng CoroutineContext. Tinutukoy nila kung saang thread o pool ng thread isasagawa ang coroutine. Kapag lumilikha ng coroutine sa pamamagitan ng launch o async, ang dispatcher ay maaaring ipasa bilang unang parameter: launch(Dispatchers.IO) { ... }. Kung hindi tinukoy ang dispatcher, ito ay minamana mula sa panlabas na CoroutineScope.

Nagbibigay ang Kotlin ng apat na built-in na dispatcher: Main, IO, Default, Unconfined. Ang bawat dispatcher ay gumagamit ng sarili nitong pool ng thread, na na-optimize para sa partikular na uri ng operasyon. Ang tamang pagpili ng dispatcher ay tumutukoy sa pagganap ng aplikasyon: ang maling pagpili ay humahantong sa lag ng interface, idle CPU cores, o hindi mahusay na paggamit ng thread.

Dispatchers.Main: UI-thread

Dispatchers.Main — dispatcher na nagpapatupad ng mga coroutine sa pangunahing thread ng Android. Ito ay inilaan para sa mga operasyong nauugnay sa interface: pag-update ng TextView, pagtawag ng notifyDataSetChanged, pagtatrabaho sa LiveData at StateFlow. Sa Android, ang dispatcher na ito ay ipinatupad sa pamamagitan ng Handler (Looper.getMainLooper()).

// Tamang paglipat sa Main para sa mga update ng UI
viewModelScope.launch(Dispatchers.IO) {
    val data = repository.fetchData()
    withContext(Dispatchers.Main) {
        _uiState.value = data
    }
}

Kung ang coroutine ay nasa Main-dispatcher na, ang karagdagang withContext(Dispatchers.Main) ay hindi lumilikha ng overhead — sinusuri ng dispatcher ang kasalukuyang thread at nilalaktawan ang paglipat. withContext ang gustong paraan ng paglipat sa pagitan ng mga dispatcher.

Dispatchers.IO: network at mga operasyon sa disk

Dispatchers.IO — dispatcher na na-optimize para sa input-output operations: mga kahilingang HTTP (Ktor, OkHttp), pagbasa at pagsulat ng mga file, pagtatrabaho sa Room o SQLDelight. Ito ay gumagamit ng pool ng 64 na thread bilang default, nasusukat sa ilalim ng load. Ang bawat bagong kahilingang IO ay maaaring lumikha ng karagdagang thread hanggang maabot ang limitasyon.

Paglilimita ng paralelismo

Upang kontrolin ang bilang ng sabay-sabay na IO operations, gamitin ang limitedParallelism(). Ang function na ito ay lumilikha ng bagong dispatcher na may limitasyon sa bilang ng parallel thread, na pumipigil sa pagkaubos ng pool sa mga malawakang operasyon.

val limitedIo = Dispatchers.IO.limitedParallelism(4)

// Mag-load ng 100 file na may limit na 4 na sabay-sabay na operasyon
coroutineScope {
    val files = (1..100).map { index ->
        async(limitedIo) {
            downloadFile("file_$index")
        }
    }
    files.awaitAll()
}

Gamitin ang IO-dispatcher para sa lahat ng operasyon kung saan ang coroutine ay gumugugol ng oras sa paghihintay (I/O-bound). Ang mga gawaing CPU-intensive sa IO-dispatcher ay hindi epektibo — sinasakop nila ang mga thread na para sa input-output, binabawasan ang throughput ng sistema.

Dispatchers.Default: mga gawaing CPU-intensive

Dispatchers.Default — dispatcher para sa mga operasyong pangkalkulasyon na nagbibigay-diin sa processor: pag-uuri, pag-filter, parsing ng JSON (Moshi, Kotlinx Serialization), pagproseso ng imahe, pag-compute. Ang laki ng pool ay katumbas ng bilang ng mga core ng processor (ngunit hindi bababa sa 2). Tinitiyak nito ang maximum na pag-load ng CPU nang walang paglipat ng konteksto.

suspend fun processData(input: List<RawRecord>): List<ProcessedRecord> {
    return withContext(Dispatchers.Default) {
        input
            .parallelStream()
            .map { transform(it) }
            .toList()
    }
}

Huwag gamitin ang Dispatchers.Default para sa IO operations — haharangin nito ang mga thread ng CPU pool na maaaring magproseso ng mga gawaing pangkalkulasyon. Ang paghihiwalay sa IO at Default ay nagbibigay-daan sa optimal na paggamit ng mga mapagkukunan ng sistema: ang IO thread ay naghihintay ng input-output, ang CPU thread ay palaging abala sa pag-compute.

Dispatchers.Unconfined: kasalukuyang thread

Dispatchers.Unconfined — isang espesyal na dispatcher na hindi nagtatali ng coroutine sa anumang pool. Sinisimulan ng coroutine ang pagpapatupad sa parehong thread kung saan tinawag ang launch/async, at pagkatapos ng pagsususpinde ay magpapatuloy sa thread na tumawag sa resume. Ang ganitong pag-uugali ay angkop para sa mga pansamantalang operasyon na hindi nangangailangan ng nakapirming konteksto.

fun main() = runBlocking {
    launch(Dispatchers.Unconfined) {
        println("Bago ang pagkaantala: ${Thread.currentThread().getName()}")
        delay(500L)
        println("Pagkatapos ng pagkaantala: ${Thread.currentThread().getName()}")
    }
}

Sa production code, ang Dispatchers.Unconfined ay bihirang ginagamit. Mga pangunahing kaso: magaan na pagbabago bago ipadala ang data sa ibang dispatcher at pagsubok. Para sa production load, gumamit ng tahasang dispatcher — ang Unconfined ay hindi mahuhulaan dahil ang thread ng pagpapatupad ay nakadepende sa implementasyon ng resume.

Paano pumili ng dispatcher

Ang pagpili ng dispatcher ay tinutukoy ng uri ng gawain: UI operations → Main, I/O-bound → IO, CPU-bound → Default, pansamantala → pagmamana mula sa scope. Para sa Android, inirerekomenda na simulan ang coroutine sa dispatcher kung saan ginagawa ang pangunahing trabaho, at bago ang pag-update ng UI, lumipat sa Main sa pamamagitan ng withContext.

• Huwag patakbuhin ang IO operations sa Main-dispatcher — hinaharangan nito ang UI
• Huwag patakbuhin ang mga gawaing CPU-intensive sa IO-dispatcher — hindi mahusay na ginagamit nito ang mga thread ng IO pool
• Gamitin ang limitedParallelism para kontrolin ang paralelismo sa malawakang IO operations
• Ilipat ang dispatcher gamit ang withContext, hindi sa paggawa ng bagong scope
• Manahin ang dispatcher mula sa scope, kung ang coroutine ay hindi nangangailangan ng partikular na pool

Para sa mga kumplikadong senaryo, pagsamahin ang mga dispatcher gamit ang operator na +: Dispatchers.IO + SupervisorJob() + CoroutineExceptionHandler. Lumilikha ito ng CoroutineContext na may tinukoy na dispatcher, paghawak ng error, at nakahiwalay na hierarchy ng Job.