Почему можно сделать 1000 корутин, а 1000 потоков сделать нельзя?

Почему корутины эффективнее потоков на больших масштабах

Основное отличие между корутинами и потоками заключается в их принципе работы и стоимости создания. Этот фундаментальный разрыв делает возможным одновременное выполнение тысячи и даже десятков тысяч корутин, что практически неосуществимо с потоками, особенно на мобильных устройствах.

Ключевые различия в модели выполнения

Потоки (Threads)

• Принадлежность ОС: Поток управляется операционной системой (ОС). Каждый поток — это нативный объект ОС, который требует собственного стека вызовов (обычно 1-2 МБ) и планируется системным планировщиком.
• Ресурсоемкость: Создание потока — дорогая операция для ОС. Потребляются значительные ресурсы памяти и процессорного времени на управление контекстом.
• Количество ограничено ОС: Система жестко ограничивает максимальное число потоков. На Android этот лимит может быть всего несколько сотен, а их одновременная активность быстро истощает ресурсы устройства.

Корутины (Coroutines)

• Принадлежность языку/библиотеке: Корутина — это абстракция уровня языка (Kotlin), управляемая собственным планировщиком внутри процесса. Она не является нативным объектом ОС.
• Легковесность: Корутина — это, по сути, серия вычислений, которые могут приостанавливаться (suspend) и возобновляться. Ее состояние хранится в небольшой структуре данных в памяти JVM, а не в системном стеке.
• Кооперативная многозадачность: Корутины добровольно уступают выполнение, приостанавливаясь (например, при ожидании сети). Это позволяет одной реальному потоку (например, Dispatcher.Default) обслуживать множество корутин, переключаясь между ними.

Техническая реализация и стоимость

Создание потока требует системных вызовов (pthread_create или аналоги) и резервирования памяти. Вот пример создания множества потоков, который может привести к сбою:

fun createTooManyThreads() {
    for (i in 1..1000) {
        Thread {
            Thread.sleep(1000) // Простая работа
        }.start()
    }
}
// Вероятно получим OutOfMemoryError или превышение лимита ОС

Создание корутин — это просто выделение небольшого объекта в памяти JVM и размещение задачи в планировщике:

fun createManyCoroutines() {
    for (i in 1..1000) {
        CoroutineScope(Dispatchers.Default).launch {
            delay(1000) // suspend функция — корутина уступает поток
            // Лёгкая работа
        }
    }
}
// Работает без проблем, все корутин выполняются на небольшом пуле потоков

Почему 1000 потоков — это проблема?

1. Память: 1000 потоков * 1 МБ (стек) ≈ 1 ГБ памяти только на стеки.
2. Нагрузка на планировщик ОС: Операционная система должна постоянно переключать контекст между тысячами потоков, что приводит к огромным накладным расходам на переключение контекста.
3. Ограничения ОС: Сама система (особенно на мобильных устройствах) имеет жесткие лимиты на число потоков в процессе.
4. Конкуренция: Все потоки могут одновременно требовать CPU, создавая конкуренцию, которая парализует систему.

Почему 1000 корутин — это нормально?

1. Память: Состояние корутины занимает байты или килобайты, а не мегабайты.
2. Минимальные переключения: Корутины выполняются кооперативно на небольшом фиксированном пуле потоков (например, на Dispatchers.Default, который имеет количество потоков, равное числу ядер CPU). Переключение между корутинами — это быстрая операция в пределах одного потока JVM.
3. Эффективное использование потоков: Корутины используют потоки только тогда, когда они активно вычисляют (не приостановлены). Один поток может обслуживать сотни корутин последовательно.
4. Контроль на уровне языка: Kotlin обеспечивает безопасное управление и структурированную конcurrency через CoroutineScope.

Итог

Корутины позволяют создавать тысячи одновременных задач, потому что они являются легковесными абстракциями, управляемыми на уровне языка и выполняемыми на небольшом пуле тяжеловесных системных потоков. Они экономят память и уменьшают нагрузку на планировщик ОС благодаря кооперативной модели. Потоки, как нативные объекты ОС, ресурсозатратны, и их массовое создание быстро истощает системные лимиты, делая тысячу потоков нереалистичной задачей на большинстве платформ, особенно в контексте Android с его ограниченными ресурсами.