Выполнение работы с корутинами само по себе не делает ее "быстрее" по сравнению с синхронным выполнением на одном потоке. Корутины позволяют эффективно управлять асинхронными операциями, избегая блокировки потока и переключения контекста, что приводит к:

Улучшенной отзывчивости UI: Главный поток не блокируется, что важно для пользовательского интерфейса.
Эффективному использованию ресурсов: Меньше накладных расходов по сравнению с созданием и управлением множеством традиционных потоков.
Упрощению асинхронного кода: Последовательный стиль написания асинхронных операций.

Если функция расчета является чисто вычислительной и не включает в себя блокирующие операции (например, ввод-вывод, сетевые запросы), то выполнение этой функции:

Без корутин и потоков (синхронно на главном потоке): Блокирует поток, UI зависает на время расчета.
С корутинами: Задача выполняется в пуле потоков (например, Dispaters.Default для CPU-интенсивных задач). Не блокирует главный поток, но общее время выполнения может быть схожим или даже немного больше из-за накладных расходов на планирование корутины.
С отдельным традиционным потоком: Задача выполняется в отдельном потоке, не блокирует главный поток. Накладные расходы на создание и управление потоком могут быть выше, чем у корутин.

Таким образом, для чистого ЦПУ-интенсивного расчета без блокирующих операций, использование корутин или отдельного потока не сделает саму вычислительную работу быстрее. Выигрыш от корутин (или потоков) в этом сценарии заключается в неблокировании основного потока, что критически важно для поддержания плавного и отзывчивого пользовательского интерфейса.

Фактически, при выполнении чистого ЦПУ-интенсивного расчета:

// Синхронно на текущем потоке (может блокировать)
fun calculateSync() {
    // Долгий расчет
}

// С корутинами (в Dispatchers.Default)
suspend fun calculateWithCoroutines() = withContext(Dispatchers.Default) {
    // Долгий расчет
}

// С традиционным потоком
fun calculateWithThread() {
    Thread {
        // Долгий расчет
    }.start()
}

Сам по себе "Долгий расчет" займет примерно одинаковое время в любом из этих случаев, при условии, что выполняются на ядрах CPU. Быстрее станет восприятие работы пользователем и способность приложения выполнять другие задачи одновременно.

Для задач, включающих блокирующие операции (например, чтение файла), корутины с использованием соответствующих диспетчеров (например, Dispatchers.IO) позволяют "освободить" поток, на котором они были запущены, для выполнения других корутин, вместо того чтобы блокировать его, как это произошло бы с традиционным потоком, ждущим завершения операции. В этом сценарии корутины могут привести к значительному повышению эффективности использования ресурсов и пропускной способности системы по сравнению с использованием большого количества традиционных потоков для блокирующих задач.

Насколько быстрее будет выполнена работа с корутинами по сравнению с выполнением функции расчета без корутин и потоков?