Перехват исключений в Kotlin для стабильности приложения
Стабильность приложения зависит не от полного отсутствия ошибок, а от того, на каком уровне они остановлены. Локально перехваченное исключение может запустить резервный сценарий, сохранить диагностические данные и продолжить работу. Необработанное исключение завершает поток или процесс, поэтому его важно зафиксировать, классифицировать и передать инфраструктуре отчётов о сбоях.
В Kotlin нет одного универсального обработчика для всех ситуаций. Обычные вызовы требуют грамотных блоков try и catch, корутины — понимания структурированной конкурентности, а необработанные ошибки потоков обрабатываются отдельно. Такое разделение не позволяет отказу одной операции остановить всё приложение и одновременно сохраняет видимость дефектов, требующих исправления.
Границы ответственности за ошибки
Исключение лучше рассматривать как нарушение ожидаемого контракта, а не как универсальный признак плохого кода. Ошибка чтения файла или сетевого запроса может быть временной, поэтому для неё нужен повтор, резервные данные или понятное состояние интерфейса. Ошибка в логике, например IllegalStateException, часто указывает на дефект, и её безопаснее зафиксировать, а не скрыть.
Граница владения ошибкой должна совпадать с архитектурной границей. Слой данных может сообщить о невозможности загрузки, но решение о повторной попытке, кэшированном значении или показе сообщения принимает вызывающий компонент. Чем выше уровень перехвата, тем выше риск превратить конкретный сбой в безликое исключение без причины.
Общий Throwable удобен для перехвата всего, но опасен: вместе с Exception он включает OutOfMemoryError, StackOverflowError и другие состояния, из которых программа не может штатно восстановиться. В обычном коде применяют конкретные типы ошибок, а CancellationException всегда повторно выбрасывают, поскольку отмена корутины — управляющий сигнал, а не сбой.
Обработка необработанных исключений в потоках
Глобальный обработчик нужен как последний рубеж перед завершением процесса. Он не заменяет локальную обработку и не позволяет продолжить повреждённый поток, но даёт единое место для сохранения стека, имени потока и причины фатальной ошибки. На Android и других JVM-платформах для этого используется Thread.UncaughtExceptionHandler.
import kotlin.system.exitProcess
fun interface CrashRecorder {
fun record(threadName: String, error: Throwable)
}
fun installCrashHandler(recorder: CrashRecorder) {
val previous = Thread.getDefaultUncaughtExceptionHandler()
Thread.setDefaultUncaughtExceptionHandler { thread, error ->
runCatching {
recorder.record(thread.name, error)
}
if (previous != null) {
previous.uncaughtException(thread, error)
} else {
exitProcess(1)
}
}
}
При установке обработчика важно сохранить предыдущую цепочку и не менять поведение завершения процесса. Делегирование исходному обработчику позволяет SDK и среде выполнения выполнить собственные действия. Если предыдущего обработчика нет, процесс нужно завершить явно; иначе главный поток может завершиться, оставив приложение в неопределённом состоянии.
Сама запись отчёта должна быть минимальной и безопасной: нельзя выполнять длительную сеть, сложное шифрование или создавать большие объекты, когда ресурсы уже могут быть исчерпаны. Полезно сохранить версию сборки, контекст операции и идентификатор связанного запроса, исключив персональные данные и секреты. Обработчик устанавливают один раз, чтобы не дублировать отчёты при повторной инициализации.
Локальный перехват и типизация ошибок
Локальный перехват применяют, когда для конкретной операции известен осмысленный сценарий восстановления. Такой блок должен находиться рядом с местом, где принимается решение продолжить работу, и не охватывать без необходимости весь пользовательский сценарий.
suspend fun loadProfile(): Profile {
return try {
repository.loadProfile()
} catch (error: CancellationException) {
throw error
} catch (error: IOException) {
Profile.empty()
}
}
| Механизм | Что обрабатывает | Как проявляется ошибка | Подходящее применение |
|---|---|---|---|
try и catch |
Известную операцию | Исключение сразу обрабатывается или передаётся дальше | Граница с понятным восстановлением |
Result |
Ожидаемый отказ | Значение содержит либо результат, либо причину | Публичный контракт функции |
runCatching |
Любой Throwable внутри блока |
Ошибка превращается в неуспешный результат | Небольшой синхронный фрагмент |
CoroutineExceptionHandler |
Необработанную ошибку корневой корутины | Выполняется финальная диагностика | Верхняя граница фоновой работы |
Thread.UncaughtExceptionHandler |
Необработанную ошибку потока | Процесс готовится к завершению | Последний рубеж на JVM и Android |
Result выражает ожидаемый отказ как значение и делает его частью контракта функции. Это удобно для парсинга, проверки ввода и вызовов, где вызывающий код обязан обработать неудачу. Однако runCatching перехватывает любой Throwable, включая отмену корутины и серьёзные ошибки среды, поэтому в suspend-функциях его применение требует особой осторожности.
Для асинхронного кода предпочтительны явные catch с понятной иерархией. Если из операции можно вернуть кэш или пустое состояние, это отражается в типе; если продолжение невозможно, исключение распространяется вверх до подходящей границы. Такой подход сохраняет первоначальную причину и упрощает тестирование.
fun parseConfig(raw: String): Result<Config> =
try {
Result.success(Config.parse(raw))
} catch (error: IllegalArgumentException) {
Result.failure(error)
}
Особенности корутин и отмены задач
В корутинах ошибка распространяется по правилам структурированной конкурентности. Необработанная ошибка в launch отменяет родительскую задачу, а CoroutineExceptionHandler используется для финальной обработки на верхней границе. Обработчик не делает операцию успешной: отмена и очистка ресурсов всё равно выполняются.
Для длительных фоновых задач полезен отдельный scope с SupervisorJob: сбой одного дочернего launch не отменяет остальные задачи. Обработчик размещают в контексте scope, чтобы наследовать его всеми запущенными корутинами.
private val errorHandler = CoroutineExceptionHandler { _, error ->
crashReporter.record(error)
}
private val appScope = CoroutineScope(
SupervisorJob() + Dispatchers.Default + errorHandler
)
fun scheduleRefresh() {
appScope.launch {
repository.refresh()
}
}
async хранит исключение в объекте Deferred до вызова await. Поэтому в обычном coroutineScope такая ошибка может отменить родителя ещё до чтения результата, а в supervisorScope — не затронуть соседние задачи, но всё равно будет повторно выброшена при await. Вызывающий код должен явно получить и обработать этот результат.
CancellationException относится к нормальному завершению отменённой задачи. Её нельзя превращать в Result.failure, отправлять в отчёт о падениях или проглатывать блоком catch: это нарушает отмену и может оставить родительскую корутину в неправильном состоянии. В finally освобождают ресурсы, но не скрывают исходную причину.
Проверка, диагностика и кроссплатформенность
Проверка обработки начинается с автоматических тестов на границах компонентов. Подменённый источник данных воспроизводит сетевую ошибку, отказ базы или неожиданный ответ, а тест подтверждает выбранное восстановление. Дополнительно проверяют, что CancellationException распространяется без отчёта о падении, а фатальная ошибка отправляется ровно один раз и не маскируется как успех.
Диагностический отчёт должен содержать класс и цепочку cause, стек вызовов, имя потока, версию приложения и контекст операции. Идентификаторы группируют однотипные падения и помогают связать сбой с конкретным запросом, тогда как полные тексты ответов и токены могут раскрыть чувствительные данные. Перед отправкой выполняют фильтрацию, а локальное сохранение ограничивают по размеру и сроку жизни.
На JVM и Android глобальный обработчик доступен непосредственно, но в Kotlin Multiplatform код восстановления и интерфейс отчёта лучше вынести в общий модуль, а платформенную запись реализовать через expect и actual. Это сохраняет одинаковую политику ошибок в приложениях для разных операционных систем, учитывая различия в модели потоков и завершении процесса. В устойчивой архитектуре локальное восстановление, контролируемая отмена и финальная диагностика работают как единый контур, а не как набор случайных catch.