Kotlin: withContext() против async-await — в чем разница и что выбрать?

Основное различие: смена контекста vs. параллельная задача

Ключевое отличие между withContext() и async-await кроется в их семантике и предназначении:

• withContext() — это инструмент для смены корутинного контекста (чаще всего диспетчера). Он выполняет блок кода в указанном контексте и возвращает результат. Это последовательная операция: корутина приостанавливается, переключается на другой поток, выполняет работу и возвращается обратно.
• async-await — это инструмент для создания параллельных (конкурентных) корутин. async запускает новую корутину, которая работает независимо от текущей. await() приостанавливает текущую корутину до получения результата из запущенной.

Когда что использовать?

Применяйте withContext, когда вам нужно просто сменить поток для выполнения тяжелой операции (сеть, диск, CPU) и получить результат последовательно. Это самый частый случай:

suspend fun loadUserFromNetwork(): User = withContext(Dispatchers.IO) {
    // сетевой запрос — выполняется на IO-потоке
    api.fetchUser()
}

Используйте async-await, когда у вас есть несколько независимых задач, которые можно выполнять одновременно. Например, загрузка двух разных данных:

suspend fun loadDashboard(): Dashboard = coroutineScope {
    val userDeferred = async { loadUser() }      // параллельно
    val newsDeferred = async { loadNews() }      // параллельно
    Dashboard(user = userDeferred.await(), news = newsDeferred.await())
}

Почему ваш первый пример одинаков?

В вашем примере с loadUser() и loadUserAsync() обе функции выполняют одну последовательную задачу. Разница в том, что withContext делает это правильно и эффективно, а async без параллельности — избыточно. async создает новую корутину, что добавляет накладные расходы. Для простой смены диспетчера всегда используйте withContext.

Подводные камни для новичков

1. Не используйте GlobalScope.async — это создает корутину вне вашего жизненного цикла, что может привести к утечкам памяти и неконтролируемому выполнению. Всегда используйте coroutineScope { } или viewModelScope.
2. async без await — это ошибка (если только вы не передаете Deferred в другую функцию). Компилятор предупредит, что результат игнорируется. Всегда вызывайте .await() или .join().
3. withContext не создает новую корутину — он лишь переключает контекст существующей. Это дешевле, чем async. Поэтому для простой смены диспетчера — только withContext.
4. Параллельность с async требует coroutineScope — иначе дочерние корутины не будут отменены при отмене родительской. Всегда оборачивайте вызовы async в coroutineScope { } или supervisorScope { }.
5. Не используйте async для одной задачи — это антипаттерн. Если у вас только один вызов, пишите withContext или просто вызывайте suspend-функцию напрямую.

Можно ли заменить async на withContext для параллельных задач?

Нет, напрямую нельзя. withContext выполняется последовательно в текущей корутине. Чтобы сделать два независимых вызова параллельно с помощью withContext, вам пришлось бы запустить их в отдельных корутинах (через launch или async). Вот неправильный пример:

// ❌ Так не работает — выполняется последовательно!
suspend fun fetchData(): Pair<String, String> {
    val one = withContext(Dispatchers.Default) { loadPart1() }
    val two = withContext(Dispatchers.Default) { loadPart2() }
    return one to two // loadPart2 начнется только после loadPart1
}

Для параллельности нужен именно async внутри coroutineScope.

Итоговая шпаргалка

• Сменить диспетчер для одной задачи → withContext
• Запустить несколько задач параллельно и дождаться их → async-await внутри coroutineScope
• Запустить задачу "забыть и не ждать" → launch
• Никогда не использовать GlobalScope без явной необходимости

Надеюсь, теперь стало понятнее! Практикуйтесь с coroutineScope и вы быстро почувствуете разницу.

suspend fun loadAll() = supervisorScope {
    val user = async { loadUser() }
    val news = async { loadNews() }
    // даже если loadUser упадет, loadNews продолжит работу
    user.await() to news.await()
}