async: шта је то, Deferred и паралелне корутине како раде

Шта је async у Kotlin Coroutines?

async — функција проширења CoroutineScope која ствара корутину са враћањем резултата. За разлику од launch, async враћа Deferred<T> — објекат који представља будућу вриједност. Корутина покренута преко async извршава се конкурентно са другим корутинама, што омогућава паралелизацију израчунавања.

async се користи када је резултат асинхроне операције потребан за даљу обраду: учитавање података из више извора, пакетна обрада колекција, паралелни захтјеви различитим API-јима. Deferred се ствара одмах, а резултат постаје доступан након завршетка корутине.

import kotlinx.coroutines.*

suspend fun String.delayedValue(): String {
    delay(1000L)
    return this
}

fun main() = runBlocking {
    val deferred: Deferred<String> = async { "Hello".delayedValue() }
    println(deferred.await())
}

Синтакса async и Deferred

Потпис async је сличан launch: исти параметри CoroutineContext, CoroutineStart и suspend-блок. Разлика је у типу који се враћа — Deferred<T> умјесто Job, гдје је T тип резултата који враћа посљедњи израз блока.

public fun <T> CoroutineScope.async(
    context: CoroutineContext = EmptyCoroutineContext,
    start: CoroutineStart = CoroutineStart.DEFAULT,
    block: suspend CoroutineScope.() -> T
): Deferred<T>

Deferred<T> — интерфејс који насљеђује Job и додаје методе await(), getCompleted(), getCompletionExceptionOrNull(). await() је suspend-функција и може се позвати само унутар корутине или друге suspend-функције. getCompleted() — метод који не блокира, баца изузетак ако корутина још није завршена.

Паралелни задаци са async

Главна предност async-а је могућност покретања задатака паралелно. Умјесто секвенцијалног чекања на сваку операцију (укупно вријеме = збир времена), async покреће корутине истовремено, смањујући укупно вријеме на вријеме најдуже операције.

Паралелно учитавање података

Типичан сценарио — учитавање профила корисника, његових поставки и историје наруџбина са три паралелна async захтјева. Након завршетка све три, резултати се обједињују у јединствени модел података.

suspend fun loadUserDashboard(userId: String): Dashboard = coroutineScope {
    val profile = async { api.getProfile(userId) }
    val settings = async { api.getSettings(userId) }
    val orders = async { api.getRecentOrders(userId) }

    Dashboard(
        profile = profile.await(),
        settings = settings.await(),
        orders = orders.await()
    )
}

Функција coroutineScope покреће подређене корутине и чека њихов завршетак прије враћања резултата. Цијели блок се извршава паралелно, а не секвенцијално.

Обрада резултата Deferred

Deferred подржава неколико метода за рад са резултатом. Поред await(), доступне су методе за провјеру статуса, добијање готове вриједности и агрегацију више Deferred преко помоћних функција Kotlin Coroutines.

За агрегацију листе Deferred користи се awaitAll() — функција која зауставља извршавање док се не заврше сви Deferred у колекцији. Ако се барем један завршио са грешком, awaitAll() баца изузетак.

suspend fun <T> loadAll(requests: List<suspend () -> T>): List<T> {
    return coroutineScope {
        val deferreds = requests.map { async { it() } }
        deferreds.awaitAll()
    }
}

Разлике између async и launch

Избор између async и launch зависи од тога да ли је потребан резултат извршавања корутине. launch враћа Job и погодан је за fire-and-forget операције, async враћа Deferred и користи се за задатке који враћају податке. По синтакси и параметрима градитељи су идентични.

• launch → Job (нема резултата), async → Deferred<T> (има резултат T)
• launch — fire-and-forget задаци (логовање, кеширање, слање аналитике)
• async — паралелна израчунавања (учитавање са више API-ја, пакетна обрада)
• Оба подржавају структурирану конкурентност и параметре CoroutineStart
• await() је доступан само за Deferred, launch не обезбјеђује резултат

Важно правило: never use async for fire-and-forget. Ако резултат корутине није потребан, користите launch. async ствара додатни трошак за стварање Deferred, који у таквом сценарију није оправдан.

Примјери async у мобилном развоју

У Android-у async се користи за паралелне операције унутар ViewModel и UseCases. Типични сценарији: истовремено учитавање профила и вијести, добијање времена са више метео сервиса, пакетна синхронизација података са сервером.

class HomeViewModel : ViewModel() {
    fun loadHomeScreen() {
        viewModelScope.launch {
            val userData = async(Dispatchers.IO) { repository.getUserData() }
            val newsFeed = async(Dispatchers.IO) { repository.getNewsFeed() }
            val notifications = async(Dispatchers.IO) { repository.getNotifications() }

            val state = HomeState(
                user = userData.await(),
                news = newsFeed.await(),
                unread = notifications.await()
            )
            _uiState.update { state }
        }
    }
}

Препоручује се умотавање групе async у coroutineScope или supervisorScope ради изолације грешака. supervisorScope омогућава наставак извршавања осталих async корутина чак и при грешци у једној од њих — корисно за некритичне операције.