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 не надає результату

Важливе правило: ніколи не використовуйте async для 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-корутинам продовжувати виконання навіть якщо одна завершилася з помилкою — корисно для некритичних операцій.