Зачем нужны корутины?

Краткий ответ

Корутины в Kotlin — это легковесные потоки выполнения, предназначенные для упрощения асинхронного и неблокирующего кода. Они нужны для замены традиционных подходов (Callback Hell, RxJava) на более читаемый, последовательный и безопасный код при работе с долгими операциями (сеть, БД, вычисления).

Подробное объяснение проблем и решений

Раньше асинхронность на Android решалась тремя основными способами, у каждого были серьёзные недостатки:

1. Потоки (Threads) и AsyncTask

Прямое использование потоков ресурсозатратно (каждый поток потребляет ~1MB стека). Создание сотен потоков для параллельных сетевых запросов невозможно.

Thread {
    val data = fetchDataFromNetwork() // Долгая операция
    runOnUiThread {
        updateUI(data) // Возвращаемся в UI-поток
    }
}.start()

Проблемы: сложная отмена, утечки памяти, громоздкий код для синхронизации.

2. Callback Hell (Ад колбэков)

Цепочка асинх<нных операций превращалась в пирамиду ужаса:

fetchUserData { user ->
    fetchUserPosts(user.id) { posts ->
        fetchComments(posts.first().id) { comments ->
            // И так далее... Код уходит вправо, обработка ошибок усложняется
        }
    }
}

Проблемы: неподдерживаемый код, сложная обработка ошибок, нарушение принципов чистой архитектуры.

3. Reactive Extensions (RxJava)

Мощная, но сложная библиотека с крутой кривой обучения.

api.getUser()
    .flatMap { user -> api.getPosts(user.id) }
    .subscribeOn(Schedulers.io())
    .observeOn(AndroidSchedulers.mainThread())
    .subscribe({ posts -> showPosts(posts) }, { error -> showError(error) })

Проблемы: избыточность для многих задач, сложность отладки, обязательная отписка для избегания утечек памяти.

Как корутины решают эти проблемы

Последовательный код, который работает асинхронно

Корутины позволяют писать код, который выглядит как последовательный, но выполняется асинхронно:

// Читается сверху вниз, как обычный код
suspend fun loadUserData() {
    try {
        // Приостанавливает корутину, не блокируя поток
        val user = userRepository.fetchUser() // Suspend функция
        val posts = postRepository.fetchPosts(user.id) // Ждём результат
        val comments = commentRepository.fetchComments(posts.first().id)
        
        withContext(Dispatchers.Main) { // Переключаемся на главный поток
            updateUI(user, posts, comments)
        }
    } catch (e: Exception) {
        // Единый центр обработки ошибок
        handleError(e)
    }
}

Ключевые преимущества корутин

1. Легковесность

Одна корутина занимает десятки байт в куче против мегабайта у потока. Можно запускать тысячи одновременно:

// 1000 параллельных запросов без создания 1000 потоков
fun fetchAllItems() = viewModelScope.launch {
    val items = List(1000) { index ->
        async { api.fetchItem(index) } // Все корутины работают на нескольких потоках
    }
    val results = items.awaitAll() // Ждём завершения всех
}

2. Структурная конкурентность (Structured Concurrency)

Корутины привязаны к Scope (области видимости). При уничтожении контекста (например, Activity/Fragment) все корутины автоматически отменяются:

class MyViewModel : ViewModel() {
    fun loadData() {
        // При очистке viewModelScope все запущенные корутины отменяются
        viewModelScope.launch {
            val data = repository.loadData() // При уходе с экрана запрос прервётся
        }
    }
}

3. Гибкие диспетчеры (Dispatchers)

• Dispatchers.Main — работа с UI (только в Android)
• Dispatchers.IO — операции ввода-вывода (сеть, БД, файлы)
• Dispatchers.Default — CPU-интенсивные задачи (сортировка, вычисления)
• Dispatchers.Unconfined — выполнение в текущем потоке (для специфичных случаев)

4. Отмена и таймауты

viewModelScope.launch {
    try {
        // Автоматическая отмена через 5 секунд
        val result = withTimeout(5000L) {
            networkRequest() // Долгая операция
        }
    } catch (e: TimeoutCancellationException) {
        // Обработка таймаута
    }
}

5. Каналы и потоки (Channels & Flow)

Для реактивных потоков данных:

// Cold stream — данные по запросу
fun getDataStream(): Flow<List<Data>> = flow {
    while (true) {
        emit(repository.fetchLatest()) // Отправляем новые данные
        delay(5000) // Ждём 5 секунд
    }
}.flowOn(Dispatchers.IO) // Определяем где выполнять

Конкретные примеры использования на Android

1. Параллельные запросы:

suspend fun fetchDashboardData(): DashboardData {
    // Запускаем параллельно
    val userDeferred = async { api.getUser() }
    val notificationsDeferred = async { api.getNotifications() }
    
    // Ждём оба результата
    return DashboardData(userDeferred.await(), notificationsDeferred.await())
}

1. Обработка жизненного цикла:

class MyFragment : Fragment() {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        
        // lifecycleScope отменяет корутины при разрушении View
        viewLifecycleOwner.lifecycleScope.launch {
            repeatOnLifecycle(Lifecycle.State.STARTED) {
                // Корутина активна только когда Fragment в состоянии STARTED
                loadData()
            }
        }
    }
}

Вывод

Корутины — это современный механизм Kotlin для асинхронного программирования, который:

• Делает код понятнее и поддерживаемее через последовательный стиль
• Экономит ресурсы через легковесную модель
• Интегрирован с жизненным циклом Android компонентов
• Снижает вероятность ошибок через структурную конкурентность
• Предоставляет богатый инструментарий (каналы, Flow, различные диспетчеры)

Для Android разработчика корутины стали стандартом де-факто, заменив RxJava в большинстве сценариев и полностью вытеснив AsyncTask и чистые колбэки. Они балансируют между простотой использования и мощью, делая асинхронный код предсказуемым и тестируемым.