🔀 Диспетчеры и отмена
Диспетчер решает, на каком потоке выполняется корутина, а отмена решает, когда она перестаёт выполняться. Ошибки тут не видны в коде: блокирующий вызов на Dispatchers.Default тормозит всё приложение, а catch (e: Exception) незаметно ломает отмену. На собеседовании здесь спрашивают размеры пулов, разницу Main и Main.immediate, как остановить цикл без suspend-вызовов и почему synchronized не подходит для корутин
🧠 Как это устроено
Диспетчеры и их пулы
Диспетчер — элемент CoroutineContext, который решает, на каком потоке выполнить корутину. Когда она просыпается после delay или ответа сети, именно диспетчер кладёт её на нужный поток
| Диспетчер | Потоки | Для чего |
|---|---|---|
Dispatchers.Main | один главный поток Android | UI, LiveData, быстрые операции |
Dispatchers.Main.immediate | тот же главный поток | то же, но без лишней постановки в очередь |
Dispatchers.Default | по числу ядер CPU, но не меньше 2 | вычисления: сортировка, парсинг JSON, diff списков |
Dispatchers.IO | до 64 или по числу ядер, если ядер больше | блокирующий ввод-вывод: файлы, синхронные HTTP-клиенты, JDBC |
Dispatchers.Unconfined | никаких своих | редкие случаи, в прикладном коде не нужен |
Лимит IO меняется системным свойством kotlinx.coroutines.io.parallelism
IO и Default делят одни и те же потоки. Это один пул с двумя лимитами на число одновременных задач, поэтому withContext(Dispatchers.IO) из Default обычно не переключает поток. Лимиты разные, потому что вычислениям больше потоков, чем ядер, не поможет. А поток с блокирующим вводом-выводом почти не тратит CPU, он просто ждёт ответа, и таких можно держать много
Отсюда ответ на частый вопрос, что будет с блокирующим кодом на Default. На телефоне с 8 ядрами у Default 8 потоков. Восемь синхронных запросов в сеть займут их все, и любая CPU-работа в приложении встанет в очередь до ответа сервера. Ошибки не будет, будут непонятные задержки
Main и Main.immediate
Dispatchers.Main на Android работает через Handler главного Looper: каждое возобновление корутины становится сообщением в очереди главного потока. Даже если корутину запустили с главного потока, её тело выполнится не сразу, а когда очередь дойдёт до этого сообщения
Main.immediate проверяет, на каком потоке находится вызывающий код. Если уже на главном, корутина выполняется сразу в текущем кадре стека, без постановки в очередь. Если нет, ведёт себя как обычный Main
// вызывается на главном потоке
fun onClick() {
println("1")
scope.launch(Dispatchers.Main) { println("2") }
println("3")
// Main: 1, 3, 2 — тело корутины ушло в очередь
// Main.immediate: 1, 2, 3 — выполнилось сразу, до первой приостановки
}С обычным Main между событием и реакцией проходит хотя бы один цикл очереди. Поэтому viewModelScope и lifecycleScope построены на Main.immediate: код, запущенный с главного потока, не ждёт лишний круг
Unconfined
Dispatchers.Unconfined не привязан ни к какому потоку. Корутина стартует в потоке вызывающего кода, а после приостановки продолжает на том, который её разбудил. В примере из документации она начинает на main, а после delay оказывается на служебном kotlinx.coroutines.DefaultExecutor
Для UI это опасно: после delay ты внезапно не на главном потоке, и документация не советует Unconfined для обычного кода. Если нужно «начать сразу, а потом вернуться в свой пул», есть launch(start = CoroutineStart.UNDISPATCHED) с обычным диспетчером
withContext
withContext(Dispatchers.IO) { ... } приостанавливает корутину, выполняет блок на другом диспетчере и возвращается с результатом на исходный. Для вызывающего кода это обычный suspend-вызов: вернёт значение или бросит исключение
Документация Android советует делать каждую suspend-функцию main-safe: функция сама уходит с главного потока, если внутри блокирующая работа, а вызывающему коду не надо думать о потоках. Диспетчер при этом передают в конструктор, а не пишут Dispatchers.IO в коде, иначе в тестах его не подменить. Как подменять, разобрано в модуле про тесты
Отмена кооперативная
job.cancel() не останавливает поток и не прерывает код. Он переводит Job в состояние Cancelling и ставит флаг. Дальше корутина должна заметить флаг сама:
- Suspend-вызов из kotlinx.coroutines:
delay,withContext,await,receive,Mutex.lock. В момент приостановки они проверяют Job и бросаютCancellationException ensureActive()— бросаетCancellationException, если корутину отменили. Ничего не приостанавливаетisActive— возвращаетfalseпосле отмены, дальше решаешь сам: выйти из цикла, сохранить промежуточный результат
Есть ещё yield(): он проверяет отмену и на мгновение отдаёт поток другим корутинам. Его ставят в долгие вычисления, чтобы одна корутина не занимала поток целиком
Своя suspend-функция на suspendCoroutine отмену не видит. Обёртки над колбэками пишут через suspendCancellableCoroutine, на нём построены все функции библиотеки
Блокирующий вызов отмена не прерывает: Thread.sleep и чтение из сокета ждут дальше. Если вызов умеет реагировать на Thread.interrupt(), его оборачивают в runInterruptible: при отмене корутины поток получит interrupt
CancellationException
Отменённая корутина завершается исключением CancellationException, оно проходит через все finally до билдера. Такую корутину считают отменённой, а не упавшей: родитель от неё не отменяется, CoroutineExceptionHandler её игнорирует. Как ведут себя остальные исключения, разобрано на странице «Исключения и SupervisorJob»
Проблема в том, что CancellationException наследуется от IllegalStateException, а значит и от Exception. Любой широкий catch ловит её вместе с ошибками сети
🛠️ На практике
Цикл без suspend-вызовов
suspend fun buildIndex(files: List<File>): Index = withContext(Dispatchers.Default) {
val index = Index()
for (file in files) {
ensureActive() // без этой строки cancel() дождётся конца всех файлов
index.add(parse(file.readText()))
}
index
}Без ensureActive() экран закрыт, а индексация жжёт CPU и батарею до последнего файла. isActive берут, когда после отмены нужно что-то сделать в обычном коде, например вернуть то, что успели посчитать. ensureActive() короче и честнее: корутина завершается так же, как на delay
Очистка после отмены: NonCancellable
finally выполняется и при отмене. Но корутина в нём уже в состоянии Cancelling, и первый же suspend-вызов внутри finally бросит CancellationException. Закрыть сокет синхронно можно, а записать черновик через suspend-метод Room нельзя: запись не начнётся
viewModelScope.launch {
try {
upload(draft)
} finally {
// корутину могли отменить, обычный suspend-вызов здесь сразу бросит исключение
withContext(NonCancellable) {
draftDao.saveStatus(draft.id, Status.INTERRUPTED)
}
}
}NonCancellable — Job, который всегда активен, поэтому внутри блока suspend-вызовы работают как обычно. Документация разрешает его только с withContext: launch(NonCancellable) разрывает связь с родителем, родитель не ждёт такую корутину и не узнает о её падении. Блок держи коротким. Работу, которая должна пережить экран, отдают внешнему scope приложения или WorkManager
withTimeout и withTimeoutOrNull
val avatar: Bitmap? = withTimeoutOrNull(3.seconds) { api.loadAvatar(id) }
?: cache.avatar(id) // не успели — показываем из кэша
val config = withTimeout(5.seconds) { api.config() } // бросит TimeoutCancellationExceptionОба отменяют блок по истечении времени. withTimeout бросает TimeoutCancellationException, withTimeoutOrNull возвращает null. Выбирают по тому, что дальше. Есть запасной вариант, как кэш выше, — withTimeoutOrNull. Без результата продолжать нельзя, тогда withTimeout и обработка ошибки выше по стеку
У withTimeout есть ловушка. TimeoutCancellationException наследуется от CancellationException, поэтому таймаут внутри launch выглядит как обычная отмена: корутина тихо завершается, родитель не падает, обработчик не вызывается. Документация советует, если таймаут должен стать ошибкой, писать withTimeoutOrNull { ... } ?: error("Timed out")
Таймаут — та же кооперативная отмена. withTimeout(1.seconds) { Thread.sleep(10_000) } отработает все 10 секунд, это пример из документации
Гонки данных
Корутины на Default или IO выполняются параллельно на разных потоках, и общая изменяемая переменная ломается так же, как с обычными потоками. counter++ из ста корутин по тысяче раз почти никогда не даст 100 000. @Volatile не спасает: он даёт видимость, но не атомарность чтения-изменения-записи. Про видимость, volatile и happens-before подробнее на странице «Java и JVM для Android-разработчика»
| Способ | Когда брать | Чем платишь |
|---|---|---|
AtomicInteger, AtomicReference, ConcurrentHashMap | счётчик, флаг, кэш по ключу | не подходит для сложного состояния из нескольких полей |
MutableStateFlow.update { } | состояние экрана во ViewModel | лямбда может выполниться несколько раз, без побочных эффектов внутри |
Mutex.withLock { } | несколько полей, проверка и запись вместе, suspend-вызов внутри секции | медленнее атомиков, не реентерабелен |
limitedParallelism(1) | всё состояние класса живёт на одном «потоке» | защищает только код между приостановками |
Почему не synchronized. Компилятор не даст вызвать suspend-функцию внутри synchronized: ошибка вида the 'delay' suspension point is inside a critical section. Монитор Java принадлежит потоку, а корутина после приостановки может продолжить на другом, и выход из монитора пришёл бы из чужого потока. С ReentrantLock компилятор такое пропустит, и unlock() из другого потока бросит IllegalMonitorStateException
Вторая причина — блокировка. Корутина, которая ждёт synchronized, держит поток. Если это главный поток, UI замирает, если Default, теряется одно из нескольких ядер. Mutex.lock() вместо этого приостанавливает корутину и отпускает поток. Короткий synchronized без suspend-вызовов внутри корутины допустим, это обычный Java-код
class TokenStore(private val api: AuthApi) {
private val mutex = Mutex()
private var token: Token? = null
suspend fun valid(): Token = mutex.withLock {
// проверка и обновление под одним замком: второй вызов подождёт, а не пойдёт в сеть
token?.takeIf { !it.isExpired() } ?: api.refresh().also { token = it }
}
}Без Mutex десять параллельных запросов с протухшим токеном сделают десять refresh, а synchronized здесь не скомпилируется
limitedParallelism(1) создаёт вид поверх существующего диспетчера, который выполняет не больше одной задачи за раз. Новых потоков он не создаёт, а документация гарантирует, что куски кода между приостановками идут строго по очереди и связаны happens-before. newSingleThreadContext даёт похожую гарантию, но создаёт отдельный поток, который потом надо закрыть через close()
⚠️ Где ошибаются
runCatching вокруг suspend-вызова. runCatching ловит Throwable, а значит и отмену. Классический пример — повтор запроса:
while (true) {
runCatching {
sync()
delay(30.seconds) // после отмены бросает сразу, но runCatching это проглотит
}
}После отмены delay бросает CancellationException мгновенно, runCatching его глотает, и цикл крутится без пауз. Корутина грузит ядро, родитель ждёт её и не завершается. Лови конкретные исключения. Если ловишь широко, ставь перед общим catch ветку catch (e: CancellationException) { throw e } или вызывай ensureActive() после runCatching
Блокирующий вызов на Default. Синхронный SDK или чтение файла на Default съедает пул размером в число ядер. Всё блокирующее уходит в withContext(Dispatchers.IO), а если у ресурса свой лимит, например у базы четыре соединения, берут Dispatchers.IO.limitedParallelism(4). Вид от IO не ограничен общими 64 потоками
Рекурсивный Mutex. Mutex не реентерабелен: повторный lock() из той же корутины приостановит её навсегда. Функция под withLock, которая вызывает другую с тем же замком, зависнет без ошибки и логов
limitedParallelism(1) как замок. Он не держит секцию через приостановку. Если внутри withContext(single) проверить кэш, уйти в сеть и записать результат, на время запроса другая корутина войдёт в тот же диспетчер, увидит пустой кэш и тоже пойдёт в сеть. Нужна атомарность через suspend-вызов — бери Mutex
🎯 Вопросы с собеседований
Чем Dispatchers.IO отличается от Default и сколько в них потоков?
Default для вычислений, его лимит равен числу ядер CPU, но не меньше двух. IO для блокирующего ввода-вывода, лимит 64 или число ядер, если их больше. Потоки у них общие, поэтому переход между ними обычно не меняет поток. Блокирующий код на Default занимает один из немногих потоков, и вычисления во всём приложении встают в очередь. Крэша не будет, будут подвисания
Чем Main отличается от Main.immediate?
Оба выполняют код на главном потоке. Main всегда ставит корутину в очередь главного Looper, даже если вызов уже на главном потоке. Main.immediate в этом случае выполняет её сразу, без лишнего круга очереди, а с другого потока ведёт себя как Main. viewModelScope и lifecycleScope используют Main.immediate, чтобы не гонять код через очередь без нужды
Что такое Dispatchers.Unconfined?
Диспетчер без своего потока: корутина стартует в потоке вызывающего кода, а после приостановки продолжает там, где её разбудили. Документация не рекомендует его для обычного кода. Если нужен немедленный старт с возвратом в свой пул, есть CoroutineStart.UNDISPATCHED
Как отменить корутину, которая крутит цикл без suspend-вызовов?
Сам cancel() её не остановит, отмена кооперативная. В цикл добавляют проверку: ensureActive() бросит CancellationException, isActive вернёт false, yield() проверит отмену и заодно отдаст поток другим корутинам. Если внутри блокирующий вызов, реагирующий на interrupt, его оборачивают в runInterruptible
Что будет, если поймать CancellationException и не пробросить?
Корутина продолжит выполнять код после catch, хотя её отменили: обновит закрытый экран, запишет лишнее в базу. Job остаётся в состоянии Cancelling, следующий suspend-вызов снова бросит исключение, а в цикле с runCatching получится бесконечный цикл без пауз. Правильно — ловить конкретные исключения или пробрасывать CancellationException
Как закрыть ресурс или записать в БД после отмены?
Очистку пишут в finally, он выполнится и при отмене. Синхронное закрытие работает как есть. Suspend-вызов в finally отменённой корутины сразу бросит CancellationException, поэтому его оборачивают в withContext(NonCancellable). NonCancellable используют только с withContext, в launch он отрывает корутину от родителя
Чем withTimeout отличается от withTimeoutOrNull?
По таймауту оба отменяют блок. withTimeout бросает TimeoutCancellationException, withTimeoutOrNull возвращает null. Подвох первого: исключение наследуется от CancellationException, и внутри launch таймаут выглядит как тихая отмена, а не ошибка. Подвох второго: если блок сам может вернуть null, таймаут от нормального результата не отличить. Оба не прервут блокирующий код, только приостановку
Почему synchronized не подходит для корутин и чем его заменить?
Suspend-вызов внутри synchronized компилятор запрещает: монитор принадлежит потоку, а корутина после приостановки может продолжить на другом. К тому же ожидание монитора блокирует поток, а на главном это фриз. Замена — Mutex.withLock: он приостанавливает корутину и держит секцию через suspend-вызовы. Для счётчиков и флагов быстрее атомики, для состояния класса подходит ограничение одним потоком через limitedParallelism(1)
📚 Что почитать
- Cancellation and timeouts — точки приостановки,
yield,runInterruptible,NonCancellableи таймауты с примерами - Shared mutable state and concurrency — один и тот же счётчик, защищённый атомиком, однопоточным контекстом и
Mutex, и чем эти способы отличаются по скорости - Dispatchers.IO — лимит потоков, общий пул с
Defaultи эластичностьlimitedParallelism - Best practices for coroutines in Android — внедрение диспетчеров, main-safety и почему не глотать
CancellationException