К содержимому
Войти

Android Road Map

🔀 Диспетчеры и отмена

Диспетчер решает, на каком потоке выполняется корутина, а отмена решает, когда она перестаёт выполняться. Ошибки тут не видны в коде: блокирующий вызов на Dispatchers.Default тормозит всё приложение, а catch (e: Exception) незаметно ломает отмену. На собеседовании здесь спрашивают размеры пулов, разницу Main и Main.immediate, как остановить цикл без suspend-вызовов и почему synchronized не подходит для корутин

🧠 Как это устроено

Диспетчеры и их пулы

Диспетчер — элемент CoroutineContext, который решает, на каком потоке выполнить корутину. Когда она просыпается после delay или ответа сети, именно диспетчер кладёт её на нужный поток

ДиспетчерПотокиДля чего
Dispatchers.Mainодин главный поток AndroidUI, 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 и ставит флаг. Дальше корутина должна заметить флаг сама:

  1. Suspend-вызов из kotlinx.coroutines: delay, withContext, await, receive, Mutex.lock. В момент приостановки они проверяют Job и бросают CancellationException
  2. ensureActive() — бросает CancellationException, если корутину отменили. Ничего не приостанавливает
  3. 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