Корутины

Корутина — это не поток. Это приостанавливаемое вычисление, которое компилятор Kotlin превращает в конечный автомат и мультиплексирует на потоки через диспетчер. Поток — это ресурс операционной системы: стек около мегабайта, планирование ядром, переключение контекста в микросекундном масштабе. «Стек» же корутины — это объект в куче (тот самый Continuation), поэтому их помещаются миллионы, а переключение между ними — обычный возврат из функции. Ключ ко всей теме — что делает приостановка: она освобождает поток, а не блокирует его. Приостановленная корутина отдаёт поток обратно в пул, и тот берёт другую работу. Именно поэтому один поток крутит сотни корутин, и именно поэтому блокирующий вызов внутри корутины — самый частый боевой баг: Thread.sleep, синхронный JDBC-запрос или любой блокирующий IO удерживает поток заложником и морит диспетчер голодом, тогда как delay() ту же паузу отдаёт даром.

На этом различии — «приостановиться или заблокировать» — держится вся тема. suspend не магическое слово рантайма, а трансформация компилятора: он добавляет скрытый параметр Continuation (continuation-passing style) и переписывает тело в машину состояний, где каждая точка приостановки — отдельный label. Билдеры launch и async запускают корутину и по-разному сообщают об ошибке; withContext не создаёт новую корутину, а лишь переключает контекст; runBlocking блокирует поток и уместен только в main и тестах. Каждая корутина рождается в scope и становится ребёнком его Job — это структурная конкурентность, гарантия того, что ни одна корутина не переживёт владельца и не утечёт (в отличие от GlobalScope). А разделяемое состояние в приостанавливаемом коде защищают Mutex, а не synchronized, потому что монитор нельзя удерживать через точку приостановки. Разбор по слоям — ниже.

Карта темы

• Корутина против потока — почему корутина не владеет потоком, чем её Continuation в куче отличается от мегабайтного стека потока и почему приостановка освобождает поток, а блокирующий вызов — нет.
• suspend и Continuation — как компилятор переписывает suspend-функцию в конечный автомат с передачей продолжения и почему suspendCancellableCoroutine — правильный мост из callback-API.
• Билдеры корутин — launch против async, где всплывает исключение каждого, почему runBlocking только для main и тестов и как получить настоящий параллелизм от двух async.
• CoroutineContext и withContext — контекст как неизменяемый набор элементов, наследование с заменой Job и withContext как последовательное переключение диспетчера без новой корутины.
• Диспетчеры — Main/IO/Default/Unconfined, почему IO эластично растёт, а Default держит по потоку на ядро, и почему IO не делает блокирующий код неблокирующим.
• Структурная конкурентность — три гарантии scope, coroutineScope против supervisorScope, viewModelScope/lifecycleScope и почему GlobalScope — канонная утечка.
• Mutex и разделяемое состояние — почему synchronized нельзя держать через приостановку, Mutex.withLock как приостанавливающий и нереентерабельный лок и безлоковые альтернативы.

Частые ошибки и ловушки

Значение для собеседований

Корутины — раздел, где интервьюер проверяет не словарь, а модель исполнения. Вопрос «чем корутина отличается от потока» — не про определения: правильный ответ звучит как «корутина не поток, а приостанавливаемое вычисление, которое компилятор превратил в конечный автомат и мультиплексирует на потоки; приостановка освобождает поток, а не блокирует его». Тот же приём применяют ко всей теме: что физически делает компилятор с suspend-функцией, что происходит с потоком в момент приостановки, почему launch и async по-разному сообщают об ошибке и в какой ровно момент scope отменяет своих детей. Практические задачи — «почему два async идут две секунды», «почему viewModelScope.launch замораживает экран», «сделайте счётчик потокобезопасным» — проверяют ту же модель под другим углом.

Что обычно проверяют:

• Чем корутина отличается от потока и почему их можно запустить миллионы.
• Что компилятор делает с suspend-функцией и почему приостановка не блокирует поток.
• launch против async: что возвращают и где всплывает исключение каждого.
• Почему runBlocking уместен в main и тестах, но не в продакшене.
• Что лежит в CoroutineContext и как ребёнок его наследует; чем withContext отличается от launch.
• Когда брать Main, IO или Default и почему IO держит куда больше потоков, чем ядер.
• Что такое структурная конкурентность и почему GlobalScope — утечка.
• Почему разделяемое состояние защищают Mutex, а не synchronized, и что Mutex не реентерабелен.

Типичный неверный ответ: «корутина — это лёгкий поток, а suspend делает вызов неблокирующим». Обе половины ложны и ведут к боевым багам. Корутина не поток и не владеет потоком — она приостанавливаемое вычисление, которое диспетчер мультиплексирует на потоки пула. А suspend сам по себе ничего не делает неблокирующим: он лишь позволяет функции приостанавливаться, но если внутри неё стоит Thread.sleep или синхронный драйвер, поток всё равно будет удержан. Кандидат, поверивший в этот миф, кладёт блокирующий вызов на Dispatchers.Default (или прямо на Main) и морит пул голодом, а на просьбу «сделать вызов неблокирующим» просто дописывает suspend к сигнатуре вместо withContext(Dispatchers.IO) вокруг блокирующего тела.