async: co to je, Deferred a paralelní koroutiny jak fungují

Co je async v Kotlin Coroutines?

async — je rozšiřující funkce CoroutineScope, která vytváří koroutinu s vracením výsledku. Na rozdíl od launch, async vrací Deferred<T> — objekt představující budoucí hodnotu. Koroutina spuštěná přes async se provádí souběžně s ostatními koroutinami, což umožňuje paralelizaci výpočtů.

async se používá, když je výsledek asynchronní operace potřebný pro další zpracování: načítání dat z více zdrojů, dávkové zpracování kolekcí, paralelní požadavky na různá API. Deferred je vytvořen okamžitě a výsledek je k dispozici po dokončení koroutiny.

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())
}

Syntaxe async a Deferred

Signatura async je podobná launch: stejné parametry CoroutineContext, CoroutineStart a suspend-blok. Rozdíl je v návratovém typu — Deferred<T> místo Job, kde T je typ výsledku vráceného posledním výrazem bloku.

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

Deferred<T> — rozhraní, které dědí Job a přidává metody await(), getCompleted(), getCompletionExceptionOrNull(). await() je suspend-funkce a může být volána pouze uvnitř koroutiny nebo jiné suspend-funkce. getCompleted() — neblokující metoda, která vyvolá výjimku, pokud koroutina ještě nebyla dokončena.

Paralelní úkoly s async

Hlavní výhodou async je možnost spouštět úkoly paralelně. Místo sekvenčního čekání na každou operaci (celkový čas = součet časů) async spouští koroutiny současně, čímž zkracuje celkový čas na čas nejdelší operace.

Paralelní načítání dat

Typický scénář — načítání profilu uživatele, jeho nastavení a historie objednávek třemi paralelními async požadavky. Po dokončení všech tří jsou výsledky sloučeny do jediného datového modelu.

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()
    )
}

Funkce coroutineScope spouští podřízené koroutiny a čeká na jejich dokončení před vrácením výsledku. Celý blok se provádí paralelně, ne sekvenčně.

Zpracování výsledků Deferred

Deferred podporuje několik metod pro práci s výsledkem. Kromě await() jsou k dispozici metody pro kontrolu stavu, získání hotové hodnoty a agregaci více Deferred pomocí pomocných funkcí Kotlin Coroutines.

Pro agregaci seznamu Deferred se používá awaitAll() — funkce, která pozastaví provádění, dokud nejsou dokončeny všechny Deferred v kolekci. Pokud alespoň jeden skončil chybou, awaitAll() vyvolá výjimku.

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

Rozdíly mezi async a launch

Výběr mezi async a launch závisí na tom, zda je potřeba výsledek provádění koroutiny. launch vrací Job a je vhodný pro operace fire-and-forget, async vrací Deferred a používá se pro úkoly vracející data. Z hlediska syntaxe a parametrů jsou stavitelé identičtí.

• launch → Job (bez výsledku), async → Deferred<T> (má výsledek T)
• launch — fire-and-forget úkoly (logování, cachování, odesílání analytiky)
• async — paralelní výpočty (načítání z více API, dávkové zpracování)
• Oba podporují strukturovanou souběžnost a parametry CoroutineStart
• await() je k dispozici pouze pro Deferred, launch neposkytuje výsledek

Důležité pravidlo: nikdy nepoužívejte async pro fire-and-forget. Pokud výsledek koroutiny není potřeba, použijte launch. async vytváří režii na vytvoření Deferred, která není v takovém scénáři ospravedlnitelná.

Příklady async v mobilním vývoji

V Androidu se async používá pro paralelní operace uvnitř ViewModel a UseCases. Typické scénáře: současné načítání profilu a zpravodajského kanálu, získávání počasí z více meteorologických služeb, dávková synchronizace dat se serverem.

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 }
        }
    }
}

Doporučuje se zabalit skupinu async do coroutineScope nebo supervisorScope pro izolaci chyb. supervisorScope umožňuje pokračovat v provádění ostatních async koroutin i při chybě v jedné z nich — užitečné pro nekritické operace.