Async/Await: kahulugan, async function at paggamit ng await

Ano ang Async/Await at asynchronous programming

Async/Await — ay isang language construct na nagpapahintulot sa pagsulat ng asynchronous code nang kasing-lin dalis ng synchronous code. Sa Swift, ito ay lumitaw sa iOS 13 / macOS 10.15 kasama ng Swift Concurrency framework. Sa Kotlin, ang async/await ay available sa pamamagitan ng coroutines library (kotlinx.coroutines) mula noong bersyon 1.3.

Bago ang pagdating ng async/await, ang asynchronous code ay binuo sa callbacks, GCD o RxSwift. Ang mga chain ng nested callbacks ay humantong sa callback hell — malalim na nesting na nagpapahirap sa pagbabasa at debugging. Nalulutas ng Async/Await ang problemang ito sa pamamagitan ng pagpapahintulot sa mga asynchronous function na “magpatigil” sa mga punto ng await at magpatuloy pagkatapos makuha ang resulta.

Ayon sa datos ng Google (2025), ang paggamit ng async/await sa Kotlin ay nagbabawas ng bilang ng mga linya ng asynchronous code ng 40–60% kumpara sa callback approach. Sa Swift, ang adoption ng Swift Concurrency ay umabot ng 68% sa mga nai-publish na application noong 2025. iOS 16 ay nagdagdag ng suporta para sa Swift Concurrency sa UIKit, SwiftUI at Foundation, na ginawang standard na tool ang async/await para sa lahat ng bagong Apple projects.

Prinsipyo ng operasyon: mga napapatigil na function

Ang pangunahing pagkakaiba ng async/await sa mga thread — pagpapatigil nang walang pag-block. Kapag ang isang function ay nakatagpo ng await, ito ay napapatigil, pinalalaya ang kasalukuyang thread para sa iba pang mga task. Pagkatapos makumpleto ang asynchronous na operasyon, ang function ay magpapatuloy sa pareho o ibang thread. Ito ay tinatawag na cooperative multitasking.

Paano gumagana ang Async/Await: pagpapatigil at pagpapatuloy

Ang async function ay kino-compile sa state machine — isang finite state machine na namamahala sa mga estado ng pagpapatupad. Sa punto ng await, ini-save ng compiler ang konteksto (mga local variable, return address) at inililipat ang kontrol sa runtime. Kapag handa na ang resulta, ibinabalik ng runtime ang konteksto at ipinagpapatuloy ang pagpapatupad.

Sa Swift, ang state machine na ito ay ipinatupad sa antas ng compiler na SIL (Swift Intermediate Language). Sa Kotlin — sa pamamagitan ng Continuation Passing Style (CPS) mechanism: bawat suspend function ay tumatanggap ng isang nakatagong parameter na Continuation, kung saan ibinabalik ang resulta. Ang parehong approach ay ginagarantiyahan ang ligtas na pagpapatuloy nang walang memory leaks.

• Swift — isinasalin ng compiler ang async function sa SIL na may runAsync coroutine frame
• Kotlin — bawat suspend function ay nakakakuha ng Continuation at nagde-delegate ng pagpapatupad sa dispatcher
• Parehong wika — pinalalaya ang thread sa await, nang hindi ita-block habang naghihintay
• Mga exception — ibinabato sa pamamagitan ng standard mechanisms (throws / try-catch)

Async/Await vs Callbacks at GCD: paghahambing ng mga approach

Ang callback approach ay nangangailangan ng pagpasa ng closure na tinatawag pagkatapos makumpleto ang operasyon. Sa tatlong sunod-sunod na request, nagreresulta ito sa tatlong antas ng nesting na may error handling sa bawat isa. Async/Await ay ginagawang tatlong sunod-sunod na linya ang parehong tatlong request na may iisang catch block.

GCD (DispatchQueue) ay nilulutas ang problema ng callback hell sa pamamagitan ng serial queues at DispatchGroup, ngunit nananatiling verbose. Para sa isang simpleng gawain — i-load ang user, pagkatapos friends, pagkatapos UI — kinakailangan ang paggawa ng queues, groups at notify blocks. Async/Await ay ginagawa ang parehong gawain sa tatlong linya sa isang function.

Ayon sa datos ng Apple WWDC 2024, ang Swift Concurrency async/await ay ang inirerekomendang approach para sa bagong code. Ang GCD ay nananatili para sa integration sa C-libraries at specific low-level scenarios ng thread processing.

Swift Concurrency: Task, TaskGroup at Actor

Task — ay ang pangunahing unit ng asynchronous work sa Swift. Ang Task ay nilikha sa konteksto ng isang umiiral na actor o sa anumang thread. Sa loob ng Task, maaaring tawagin ang async functions sa pamamagitan ng await. TaskGroup ay nagpapahintulot sa pagpapatakbo ng maraming child task nang magkapareho at pagkolekta ng kanilang mga resulta — katulad ng DispatchGroup ngunit mas malakas.

Actor — ay isang thread-safe reference type na nagproprotekta sa estado nito mula sa data races. Ginagarantiyahan ng compiler na ang access sa properties ng actor ay posible lamang sa pamamagitan ng async calls o sa loob ng actor isolation. Actor ay pumapalit sa serial DispatchQueue para sa proteksyon ng shared mutable state nang walang manual locks.

Structured Concurrency

Ang prinsipyo ng Structured Concurrency ay nagsasabi: bawat asynchronous task ay may magulang, at ang magulang ay hindi makukumpleto hangga't hindi nakumpleto ang lahat ng anak nito. Kung ang task A ay naglunsad ng Task { await B() }, ang A ay naghihintay sa B. Ito ay pumipigil sa pagtagas ng task at tinitiyak ang predictable lifecycle.

Async/Await sa Kotlin gamit ang coroutines

Sa Kotlin, ang async/await ay ipinatupad sa pamamagitan ng coroutines — magaan na thread ng wika. Ang function ay minarkahan ng keyword na suspend (katulad ng Swift’s async). Para sa paglunsad, ginagamit ang launch (fire-and-forget) o async (na may resulta). Ang Await ay tinatawag para makuha ang resulta mula sa async.

Dispatcher ay tumutukoy kung saang thread pool isinasagawa ang coroutine: Dispatchers.Main para sa UI, Dispatchers.IO para sa network/disk at Dispatchers.Default para sa CPU-intensive task. Structured Concurrency ay tinitiyak sa pamamagitan ng CoroutineScope — kapag kinansela ang scope, lahat ng child coroutines ay kinakansela rin.

Ayon sa datos ng JetBrains (2025), 97% ng Android applications sa Google Play ay gumagamit ng kotlinx.coroutines, at 82% sa kanila ay gumagamit ng async/await para sa network requests. Ang coroutines ay naging de facto standard para sa asynchronous programming sa Android. Kotlin Multiplatform ay sumusuporta rin sa coroutines, na nagpapahintulot sa paggamit ng shared asynchronous code sa Android, iOS at server side.

Mga halimbawa ng code na may Async/Await sa Swift at Kotlin

Tingnan natin ang dalawang halimbawa para sa bawat wika: sequential data loading at parallel requests gamit ang TaskGroup o async/await.

Swift: sequential async calls

await ay nagpapatigil ng pagpapatupad hanggang makuha ang data ng user, pagkatapos — hanggang makuha ang mga kaibigan. Walang nested closures.

func loadProfile() async throws -> Profile {
    let user = try await api.fetchUser()
    let friends = try await api.fetchFriends(for: user.id)
    return Profile(user: user, friends: friends)
}

Swift: parallel requests gamit ang TaskGroup

TaskGroup ay nagpapatakbo ng mga task nang magkapareho at nangongolekta ng mga resulta sa array. Ang pagkakasunod-sunod ng mga resulta ay maaaring hindi tumugma sa pagkakasunod-sunod ng paglunsad.

func loadParallel() async throws -> [String] {
    await withThrowingTaskGroup(of: String.self) { group in
        group.addTask { try await api.fetchName() }
        group.addTask { try await api.fetchEmail() }
        group.addTask { try await api.fetchAvatar() }
        var results = [String]()
        for try await value in group { results.append(value) }
        return results
    }
}

Kotlin: sequential call gamit ang async/await

Ang mga suspend function ay maaaring tumawag sa iba pang suspend function. Katulad ng Swift: sequential calls.

suspend fun loadProfile(): Profile {
    val user = api.fetchUser()
    val friends = api.fetchFriends(user.id)
    return Profile(user, friends)
}

Kotlin: parallel requests gamit ang async/await

Sa Kotlin, ang parallelism ay nakakamit sa pamamagitan ng coroutineScope na may async para sa bawat request.

suspend fun loadParallel(): List<String> = coroutineScope {
    val name = async { api.fetchName() }
    val email = async { api.fetchEmail() }
    val avatar = async { api.fetchAvatar() }
    listOf(name.await(), email.await(), avatar.await())
}

Mga karaniwang pagkakamali at limitasyon ng Async/Await

Nakalimutang Task { } — ang isang asynchronous function ay hindi maaaring tawagin mula sa synchronous context nang walang pagbabalot sa Task. Sa Swift, ito ay nagiging error sa compilation. Sa Kotlin, kinakailangan ang paglunsad sa pamamagitan ng lifecycleScope o viewModelScope. Ang pagtatangkang tumawag ng suspend function mula sa ordinaryong function ay hindi makaka-compile.

Labis na paggamit ng async nang hindi kinakailangan

Hindi lahat ng function ay kailangang gawing asynchronous. CPU-intensive task na walang I/O ay hindi nakikinabang mula sa async — mas mainam na isagawa ang mga ito sa DispatchQueue na may .userInitiated QoS. Ang Async/Await ay na-optimize para sa I/O-bound operations: network, disk, paghihintay.

Pag-block sa main thread sa pamamagitan ng .result

Ang paggamit ng .result sa main thread (synchronous na paghihintay ng resulta ng async function) ay humahantong sa pag-block. Sa Swift, ang Task.synchronousWait ay hindi inirerekomenda ng Apple. Sa Kotlin, ang runBlocking sa main thread ay isang antipattern, gamitin ang lifecycleScope.

Pagtagas ng Task sa pagkansela

Kung ang Task ay hindi nai-save sa property ng class, pagkatapos lumabas sa konteksto ito ay makakansela. Sa Swift, ang Task ay scoped — ang lifecycle nito ay nakatali sa lumikha na konteksto. I-save ang Task sa property kung kinakailangan ang long-running operation.