Что такое асинхронность

Ответ

Асинхронность — это выполнение операций без блокировки основного потока. В Android это критично, т.к. UI работает в главном потоке, и долгие операции (сеть, БД) должны выполняться асинхронно.

Основные подходы:

Threads — базовый способ, но сложно управлять
AsyncTask (устарел) — простой, но с ограничениями
RxJava — мощный, но сложный
Coroutines — современное решение (рекомендуется)

Пример с корутинами:

viewModelScope.launch {
    val data = withContext(Dispatchers.IO) { 
        repository.fetchData() // Блокирующий вызов
    }
    updateUi(data) // Возвращаемся в главный поток
}

Ответ 18+ 🔞

Слушай, ну это ж классика, ёпта. Асинхронность — это когда ты можешь параллельно делать несколько дел, а не стоять как идиот и ждать, пока чайник закипит, чтобы начать бутерброд мазать. В андроиде это вообще святое, потому что главный поток — это как царь-батюшка, его трогать низя. Если ты в нём начнёшь сетевой запрос гонять или в базу лазить, то интерфейс просто встанет колом, и пользователь подумает, что его телефон накрылся медным тазом. И будет прав, пидарас шерстяной.

Раньше-то народ мучился, как мог. Смотри, какие были варианты:

Потоки (Threads). Ну, базовый способ, да. Но это как собрать мебель из Икеи без инструкции — вроде и болты есть, и доски, а в итоге получается манда с ушами. Запустил кучу потоков — потом нихуя не поймёшь, кто где завис, кто что отменил, и приложение бздит от утечек памяти.
AsyncTask. О, этот усатый дед! В своё время все им пользовались, а сейчас он — как старый хромой конь. Простой, да, но с такими ограничениями, что волосы дыбом. Отменишь его не вовремя — получишь чих-пых тебя в сраку в виде утечки. Для простых задач сойдёт, но для чего-то серьёзного — доверия ебать ноль.
RxJava. Мощная штука, овердохуища возможностей. Но сложность там такая, что нужно быть чуть ли не шаманом, чтобы всё это освоить. Один только Observable от Flowable отличить — уже хитрая жопа. Не для слабаков.
Корутины (Coroutines). Вот это, бля, современная магия! Рекомендуется использовать, потому что код читается как обычный, последовательный, а работает асинхронно. Красота!

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

viewModelScope.launch { // Запускаем корутину в скоупе ViewModel
    val data = withContext(Dispatchers.IO) { // Говорим: "Чувак, иди потрудись в фоновом потоке"
        repository.fetchData() // Вот тут твой блокирующий вызов — сеть или БД
    }
    updateUi(data) // А здесь мы уже автоматом вернулись в главный UI-поток. Всё!
}

Суть в чём? Мы написали код, который выглядит прямолинейно, будто бы мы ждём результат fetchData() на месте. Но на самом деле, когда выполнение доходит до withContext(Dispatchers.IO), оно не блокирует интерфейс, а тихонечко перепрыгивает в фоновый пул потоков, делает свою грязную работу, а потом так же незаметно возвращается обратно в главный поток, чтобы обновить UI. И никаких костылей, хуй с винтом! Пользователь скроллит ленту, а данные подгружаются. Удивление пиздец, да? Вот за это корутины и любят.