Что такое Coroutines - Хак Собесов

Ответ

Coroutines — это легковесные потоки, позволяющие писать асинхронный код последовательно, без колбэков. Они приостанавливают выполнение, не блокируя поток, и возобновляют работу при готовности результата.

Ключевые особенности:

Работают в рамках одного потока (не создают новых Thread)
Управляются диспетчерами (Dispatchers.IO, Main, Default)
Поддерживают отмену (cancellation)
Меньше накладных расходов, чем у потоков

viewModelScope.launch(Dispatchers.IO) {
    val data = repository.fetchData() // suspend-функция
    withContext(Dispatchers.Main) {
        updateUI(data) // Обновляем UI в главном потоке
    }
}

Используются для:

Асинхронных операций
Работы с БД
Сетевых запросов
Параллельных задач (async/await)

Ответ 18+ 🔞

А, корутины! Ну это ж, блядь, просто ёперный театр какой-то, если честно. Представь себе: тебе надо сделать какую-то долгую хрень, типа запроса в сеть, а UI не должен висеть, как будто на дворе 2002-й год. Раньше бы нагородили колбэков, а потом ещё колбэков в колбэках, пока не получится пиздопроебибна, которую через месяц сам не разберёшь.

А тут приходят они — корутины. Лёгкие такие, почти как потоки, но не потоки. Хуй с горы, если по-простому. Они в рамках одного основного потока работают, новых Thread не плодят, овердохуища ресурсов не жрут. Просто говорят: «Я тут на секунду приостановлюсь, подожду, пока данные из сети придут, а ты, поток, иди дальше рисуй кнопочки, не блокируйся». И волнение ебать — всё работает плавненько.

Чем они круты, коротко:

В одном потоке торчат. Не создают новых, как обычные треды, а значит, переключения контекста и прочей тяжелой артиллерии нет. Быстро, ёпта.
Диспетчеры рулят. Есть Dispatchers.IO — для ввода-вывода (сеть, файлы), Main — для UI, Default — для сложных вычислений. Сам решаешь, где что выполнять.
Отмену поддерживают. Запустил операцию, передумал — отменил. Не будет висеть где-то в фоне, как призрак.
Накладных расходов — ноль ебать. Их можно тысячи запустить, и комп не загнётся, в отличие от потоков. Серьёзно, ни хуя себе эффективность.

Вот смотри, как это выглядит в коде, тут всё понятно:

viewModelScope.launch(Dispatchers.IO) { // Запускаем на пуле для IO
    val data = repository.fetchData() // Вызываем suspend-функцию — корутина приостановится тут и не будет блокировать поток!
    withContext(Dispatchers.Main) { // А потом БАЦ! — переключаемся на главный поток
        updateUI(data) // И безопасно обновляем интерфейс
    }
}

Красота же? Никаких runOnUiThread, никаких хэндлеров. Всё последовательно написано, как будто синхронный код, а работает асинхронно. Сам от себя охуеваю, когда вспоминаю, как раньше это делали.

Где эту хитрую жопу применяют?

Асинхронные операции — основа основ. Сетевые запросы, работа с БД.
Параллельные задачи — через async/await можно несколько штук запустить и потом результаты собрать. Не то что Thread, где синхронизация — отдельная песня.
Вообще, везде, где нужно делать несколько дел «одновременно», но без головной боли. Просто берёшь и пишешь, без лишнего геморроя. Пизда рулю, короче.