Отмена и обработка ошибок корутин — бесплатный тест онлайн

Вопрос 1 из 25

Какой контракт определяет наблюдаемый результат «Suspend-очистка после отмены»?

// На ревью требуется объяснить причину поведения.
import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try { awaitCancellation() }
        finally {
            withContext(NonCancellable) { delay(10); println("closed") }
        }
    }
    yield() // дочерняя корутина успевает войти в try
    job.cancelAndJoin()
}

Ключевым считают контракт: Delay игнорируется компилятором внутри finally. Синхронная очистка выполняется в `finally`; для suspend-очистки после отмены нужен ограниченный `NonCancellable` контекст. Здесь действует следующее правило: NonCancellable создаёт отдельную корутину, не связанную с job. Объяснение опирается на утверждение: Finally выполняется только при обычном завершении, но handler печатает строку вместо него. Причину поведения формулируют так: Отмена откладывается до естественного возврата awaitCancellation.

Вопрос 2 из 25

Какое изменение лучше всего защищает границу «Виртуальное время и отмена poll»?

// Сохраните назначение фрагмента, но укрепите его контракт.
import kotlinx.coroutines.*
suspend fun poll(read: suspend () -> Unit) {
    while (currentCoroutineContext().isActive) {
        read()
        delay(1_000)
    }
}

Зафиксировать текущее поведение регрессионным тестом: Проверить только, что в исходнике встречается `isActive`. Ограничиться поясняющим комментарием о том, что остановить тестовый процесс после первого вызова read. Передать ответственность владельцу вызова, предполагая, что запустить poll напрямую и ждать Thread.sleep(1100). Добавить локальную обработку результата, потому что мокировать currentCoroutineContext так, чтобы он сразу возвращал false, не проверяя рабочую итерацию. Добавить сценарий отмены во время read и убедиться, что CancellationException не перехватывается зависимостью.

Вопрос 3 из 25

Какой дополнительный сценарий нужен для «Повторный throw отмены»?

Проверить, сохраняется ли контракт, когда отмена не сработает до завершения всех десяти delay. Проверить крайний ввод, при котором будет `cancel`, но программа завершится непойманной ошибкой. Блок `NonCancellable` допустим для короткой suspend-очистки, но задерживает завершение и не подходит для обычной работы. Зафиксировать сценарий, где ожидается: Сначала `joined`, затем `cancel`, поскольку join не ждёт finally/catch. Считать опасной границей ситуацию, где будет только `joined`, потому что CancellationException нельзя перехватить.

Вопрос 4 из 25

Предложенная правка для «Независимые дети supervisorScope» звучит так: Применять supervision для независимых задач и определить отдельный канал наблюдения ошибки каждого ребёнка. Какой недостаток важнее обсудить?

Частичная доступность полезна для независимых виджетов или запросов, но может оставить систему в неоднородном состоянии. Граница полезности решения описывается условием: B запускается только после успешного a.join. После правки останется ограничение: Ошибка a автоматически превращается в результат b. Главная цена решения — необходимость учитывать, что supervisorScope подавляет и забывает все исключения без обработки. Сопровождение усложнится, если окажется, что b обязательно отменяется, как в обычном coroutineScope.

Вопрос 5 из 25

Какое сообщение обработает `handler`?

// Проследите фактическое выполнение без изменения кода.
import kotlinx.coroutines.*

val handler = CoroutineExceptionHandler { _, e -> println(e.message) }
fun main() = runBlocking {
    val scope = CoroutineScope(SupervisorJob() + handler)
    scope.launch { error("launch") }.join()
    val d = scope.async { error("async") }
    runCatching { d.await() }
    scope.cancel()
}

Он обработает оба сообщения сразу при создании задач. Он не обработает ничего: handler работает лишь в GlobalScope. Он преобразует обе ошибки в успешный Unit. Он обработает `launch`; исключение `async` хранится в Deferred и наблюдается через `await`. Он обработает только `async`, потому что Deferred наследует Job.

Вопрос 6 из 25

Какой тест лучше всего защищает край контракта «Виртуальное время и отмена poll»?

Зафиксировать сценарий, где ожидается: Остановить тестовый процесс после первого вызова read. Проверить крайний ввод, при котором мокировать currentCoroutineContext так, чтобы он сразу возвращал false, не проверяя рабочую итерацию. Добавить регрессию на гипотезу: Проверить только, что в исходнике встречается `isActive`. Если fake `read` не приостанавливается и цикл не содержит delay, тест может зависнуть до явного yield или advance. Отдельно проверить предположение, что запустить poll напрямую и ждать Thread.sleep(1100).

Вопрос 7 из 25

Решение для «Повторный throw отмены»: Не ловить Throwable без отдельного пропуска CancellationException; в вычислительных циклах регулярно проверять active-состояние. Что в нём остаётся не бесплатным?

Главная цена решения — необходимость учитывать, что отмена не сработает до завершения всех десяти delay. Сопровождение усложнится, если окажется, что сначала `joined`, затем `cancel`, поскольку join не ждёт finally/catch. Кооперативность позволяет безопасно освобождать ресурсы, однако код обязан своевременно достигать точек проверки отмены. Решение оправдано лишь при условии: Будет только `joined`, потому что CancellationException нельзя перехватить. Обратная сторона изменения состоит в том, что будет `cancel`, но программа завершится непойманной ошибкой.

Вопрос 8 из 25

Как supervisorScope влияет на `b`?

// Проследите фактическое выполнение без изменения кода.
import kotlinx.coroutines.*

fun main() = runBlocking {
    supervisorScope {
        val a = launch { error("boom") }
        val b = async { delay(20); 7 }
        a.join()
        println(b.await())
    }
}

Ошибка a автоматически превращается в результат b. B запускается только после успешного a.join. Сбой `a` не отменит соседнюю задачу `b`, поэтому `b.await()` вернёт 7. B обязательно отменяется, как в обычном coroutineScope. SupervisorScope подавляет и забывает все исключения без обработки.

Вопрос 9 из 25

Какое утверждение точнее всего объясняет поведение фрагмента «Handler для launch и async»?

// На ревью требуется объяснить причину поведения.
import kotlinx.coroutines.*

val handler = CoroutineExceptionHandler { _, e -> println(e.message) }
fun main() = runBlocking {
    val scope = CoroutineScope(SupervisorJob() + handler)
    scope.launch { error("launch") }.join()
    val d = scope.async { error("async") }
    runCatching { d.await() }
    scope.cancel()
}

Здесь действует следующее правило: Он преобразует обе ошибки в успешный Unit. Объяснение опирается на утверждение: Он обработает только `async`, потому что Deferred наследует Job. Наблюдаемое поведение выводят из того, что он не обработает ничего: handler работает лишь в GlobalScope. CoroutineExceptionHandler — последний обработчик необработанных исключений root launch; он не заменяет try/catch вокруг `await`. Причину поведения формулируют так: Он обработает оба сообщения сразу при создании задач.

Вопрос 10 из 25

Какой рефакторинг делает поведение «Suspend-очистка после отмены» предсказуемее?

// Сохраните назначение фрагмента, но укрепите его контракт.
import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try { awaitCancellation() }
        finally {
            withContext(NonCancellable) { delay(10); println("closed") }
        }
    }
    yield() // дочерняя корутина успевает войти в try
    job.cancelAndJoin()
}

Добавить локальную обработку результата, потому что отмена откладывается до естественного возврата awaitCancellation. Добавить защитную проверку перед фрагментом, поскольку delay игнорируется компилятором внутри finally. Спрятать участок за вспомогательной функцией, сохранив предположение: NonCancellable создаёт отдельную корутину, не связанную с job. Закрывать ресурсы через `use` или finally, задавать таймаут очистки и не выполнять в NonCancellable долгие сетевые операции. Ограничиться поясняющим комментарием о том, что finally выполняется только при обычном завершении, но handler печатает строку вместо него.

Вопрос 11 из 25

Какие слова будут выведены?

// Проследите фактическое выполнение без изменения кода.
import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try { repeat(10) { delay(100) } }
        catch (e: CancellationException) { println("cancel"); throw e }
    }
    delay(10); job.cancelAndJoin(); println("joined")
}

Будет `cancel`, но программа завершится непойманной ошибкой. Отмена не сработает до завершения всех десяти delay. Сначала `joined`, затем `cancel`, поскольку join не ждёт finally/catch. Будут выведены `cancel`, затем `joined`: `join` дождётся очистки после отмены. Будет только `joined`, потому что CancellationException нельзя перехватить.

Вопрос 12 из 25

Что в семантике Kotlin или используемого API объясняет «Независимые дети supervisorScope»?

// На ревью требуется объяснить причину поведения.
import kotlinx.coroutines.*

fun main() = runBlocking {
    supervisorScope {
        val a = launch { error("boom") }
        val b = async { delay(20); 7 }
        a.join()
        println(b.await())
    }
}

Механика примера описывается утверждением: B обязательно отменяется, как в обычном coroutineScope. Семантика фрагмента приводит к тому, что supervisorScope подавляет и забывает все исключения без обработки. Причина результата в том, что ошибка a автоматически превращается в результат b. Контракт здесь понимают так: B запускается только после успешного a.join. Supervisor разрывает распространение сбоя от одного ребёнка к другим, но не отмену родителя к детям и не обязанность обработать ошибку.

Вопрос 13 из 25

Как укрепить «Handler для launch и async», не переписывая соседние модули?

// Сохраните назначение фрагмента, но укрепите его контракт.
import kotlinx.coroutines.*

val handler = CoroutineExceptionHandler { _, e -> println(e.message) }
fun main() = runBlocking {
    val scope = CoroutineScope(SupervisorJob() + handler)
    scope.launch { error("launch") }.join()
    val d = scope.async { error("async") }
    runCatching { d.await() }
    scope.cancel()
}

Добавить защитную проверку перед фрагментом, поскольку он обработает оба сообщения сразу при создании задач. Оставить реализацию без изменений и закрепить тестом предположение: Он не обработает ничего: handler работает лишь в GlobalScope. Вынести участок в отдельный метод, считая верным следующее: Он преобразует обе ошибки в успешный Unit. Для async обрабатывать ошибку в месте await, а handler использовать для централизованной диагностики корневых fire-and-observe задач. Перенести проверку в вызывающий код, исходя из того, что он обработает только `async`, потому что Deferred наследует Job.

Вопрос 14 из 25

Какой дополнительный сценарий нужен для «Suspend-очистка после отмены»?

Проверить крайний ввод, при котором отмена откладывается до естественного возврата awaitCancellation. Проверить, сохраняется ли контракт, когда nonCancellable создаёт отдельную корутину, не связанную с job. Добавить граничный тест на утверждение: Delay игнорируется компилятором внутри finally. Исключение из cleanup способно заслонить исходную причину; его нужно присоединять или журналировать с сохранением контекста. Зафиксировать сценарий, где ожидается: Finally выполняется только при обычном завершении, но handler печатает строку вместо него.

Вопрос 15 из 25

В «Виртуальное время и отмена poll» выбрали решение: Добавить сценарий отмены во время read и убедиться, что CancellationException не перехватывается зависимостью. Какова его реальная цена?

Главная цена решения — необходимость учитывать, что проверить только, что в исходнике встречается `isActive`. Граница полезности решения описывается условием: Мокировать currentCoroutineContext так, чтобы он сразу возвращал false, не проверяя рабочую итерацию. Главный риск формулируют так: Остановить тестовый процесс после первого вызова read. Виртуальный планировщик делает тест быстрым, но код с реальными блокирующими вызовами всё равно требует отдельной интеграционной проверки. Сопровождение усложнится, если окажется, что запустить poll напрямую и ждать Thread.sleep(1100).

Вопрос 16 из 25

Какая правка устраняет причину риска в «Независимые дети supervisorScope», а не только его проявление?

// Сохраните назначение фрагмента, но укрепите его контракт.
import kotlinx.coroutines.*

fun main() = runBlocking {
    supervisorScope {
        val a = launch { error("boom") }
        val b = async { delay(20); 7 }
        a.join()
        println(b.await())
    }
}

Спрятать участок за вспомогательной функцией, сохранив предположение: B обязательно отменяется, как в обычном coroutineScope. Добавить защитную проверку перед фрагментом, поскольку ошибка a автоматически превращается в результат b. Оставить реализацию без изменений и закрепить тестом предположение: SupervisorScope подавляет и забывает все исключения без обработки. Применять supervision для независимых задач и определить отдельный канал наблюдения ошибки каждого ребёнка. Вынести участок в отдельный метод, считая верным следующее: B запускается только после успешного a.join.

Вопрос 17 из 25

Где упрощённое объяснение «Handler для launch и async» перестаёт работать?

Воспроизвести редкий сценарий, где он не обработает ничего: handler работает лишь в GlobalScope. Handler не может восстановить уже завершившуюся с ошибкой корутину; решение о повторе или состоянии принимается раньше. Добавить граничный тест на утверждение: Он обработает оба сообщения сразу при создании задач. Отдельно воспроизвести случай, в котором он обработает только `async`, потому что Deferred наследует Job. Добавить тест на состояние, при котором он преобразует обе ошибки в успешный Unit.

Вопрос 18 из 25

Решение для «Suspend-очистка после отмены»: Закрывать ресурсы через `use` или finally, задавать таймаут очистки и не выполнять в NonCancellable долгие сетевые операции. Что в нём остаётся не бесплатным?

Обратная сторона изменения состоит в том, что finally выполняется только при обычном завершении, но handler печатает строку вместо него. После правки останется ограничение: Delay игнорируется компилятором внутри finally. Сопровождение усложнится, если окажется, что nonCancellable создаёт отдельную корутину, не связанную с job. Гарантированная очистка повышает надёжность, но слишком долгий non-cancellable участок замедляет shutdown и тесты. Решение оправдано лишь при условии: Отмена откладывается до естественного возврата awaitCancellation.

Вопрос 19 из 25

Какой тест проверяет отменяемость без ожидания реальной секунды?

// Проследите фактическое выполнение без изменения кода.
import kotlinx.coroutines.*
suspend fun poll(read: suspend () -> Unit) {
    while (currentCoroutineContext().isActive) {
        read()
        delay(1_000)
    }
}

Мокировать currentCoroutineContext так, чтобы он сразу возвращал false, не проверяя рабочую итерацию. Проверить только, что в исходнике встречается `isActive`. Запустить poll напрямую и ждать Thread.sleep(1100). Остановить тестовый процесс после первого вызова read. В `runTest` отменить Job после продвижения виртуального времени и проверить остановку вызовов `read`.

Вопрос 20 из 25

На какой контракт языка или библиотеки опирается «Повторный throw отмены»?

// На ревью требуется объяснить причину поведения.
import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try { repeat(10) { delay(100) } }
        catch (e: CancellationException) { println("cancel"); throw e }
    }
    delay(10); job.cancelAndJoin(); println("joined")
}

Наблюдаемое поведение выводят из того, что отмена не сработает до завершения всех десяти delay. Причину поведения формулируют так: Будет `cancel`, но программа завершится непойманной ошибкой. Объяснение опирается на утверждение: Сначала `joined`, затем `cancel`, поскольку join не ждёт finally/catch. Отмена корутин кооперативна и обычно распространяется через CancellationException, которую после локальной очистки следует пробрасывать. Поведение связывают с правилом: Будет только `joined`, потому что CancellationException нельзя перехватить.

Вопрос 21 из 25

Предложенная правка для «Handler для launch и async» звучит так: Для async обрабатывать ошибку в месте await, а handler использовать для централизованной диагностики корневых fire-and-observe задач. Какой недостаток важнее обсудить?

Главная цена решения — необходимость учитывать, что он не обработает ничего: handler работает лишь в GlobalScope. Главное журналирование полезно, но опора только на handler без предметной обработки приводит к тихой потере результата. Сопровождение усложнится, если окажется, что он обработает только `async`, потому что Deferred наследует Job. Обратная сторона изменения состоит в том, что он обработает оба сообщения сразу при создании задач. Граница полезности решения описывается условием: Он преобразует обе ошибки в успешный Unit.

Вопрос 22 из 25

Почему `closed` будет напечатано?

// Проследите фактическое выполнение без изменения кода.
import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try { awaitCancellation() }
        finally {
            withContext(NonCancellable) { delay(10); println("closed") }
        }
    }
    yield() // дочерняя корутина успевает войти в try
    job.cancelAndJoin()
}

NonCancellable создаёт отдельную корутину, не связанную с job. `finally` выполнится при отмене, а `NonCancellable` позволит закончить короткую suspend-очистку. Finally выполняется только при обычном завершении, но handler печатает строку вместо него. Отмена откладывается до естественного возврата awaitCancellation. Delay игнорируется компилятором внутри finally.

Вопрос 23 из 25

Какое правило определяет поведение фрагмента «Виртуальное время и отмена poll»?

// На ревью требуется объяснить причину поведения.
import kotlinx.coroutines.*
suspend fun poll(read: suspend () -> Unit) {
    while (currentCoroutineContext().isActive) {
        read()
        delay(1_000)
    }
}

Контракт здесь понимают так: Остановить тестовый процесс после первого вызова read. Причина результата в том, что запустить poll напрямую и ждать Thread.sleep(1100). Тест отмены должен наблюдать прекращение эффекта и завершение Job; виртуальное время устраняет реальные задержки, но не заменяет cancel/join. Семантика фрагмента приводит к тому, что проверить только, что в исходнике встречается `isActive`. Поведение связывают с правилом: Мокировать currentCoroutineContext так, чтобы он сразу возвращал false, не проверяя рабочую итерацию.

Вопрос 24 из 25

Какую точечную правку стоит принять на ревью фрагмента «Повторный throw отмены»?

// Сохраните назначение фрагмента, но укрепите его контракт.
import kotlinx.coroutines.*

fun main() = runBlocking {
    val job = launch {
        try { repeat(10) { delay(100) } }
        catch (e: CancellationException) { println("cancel"); throw e }
    }
    delay(10); job.cancelAndJoin(); println("joined")
}

Оставить структуру прежней, документировав утверждение: Будет `cancel`, но программа завершится непойманной ошибкой. Передать ответственность владельцу вызова, предполагая, что отмена не сработает до завершения всех десяти delay. Обернуть операцию проверкой и не менять основной контракт: Сначала `joined`, затем `cancel`, поскольку join не ждёт finally/catch. Вынести участок в отдельный метод, считая верным следующее: Будет только `joined`, потому что CancellationException нельзя перехватить. Не ловить Throwable без отдельного пропуска CancellationException; в вычислительных циклах регулярно проверять active-состояние.

Вопрос 25 из 25

Где поведение «Независимые дети supervisorScope» требует отдельной проверки?

Ошибка в самом теле supervisorScope, а не в дочерней задаче, отменит его детей как обычно. Отдельно проверить предположение, что supervisorScope подавляет и забывает все исключения без обработки. Проверить соседний случай: Ошибка a автоматически превращается в результат b. Добавить регрессию на гипотезу: B запускается только после успешного a.join. Проверить границу полезности утверждения: B обязательно отменяется, как в обычном coroutineScope.