C# C# · 25 вопросов · ~70 мин · ⏱ Таймер 10:00 · Сложный ·

Отмена и координация задач

Посвящён отмене, таймаутам и координации множества задач. Сценарии охватывают передачу CancellationToken, WhenAll, ограниченный fan-out, частичные ошибки и разницу между прекращением ожидания и остановкой самой операции.

Отвечено: 0 из 25

⏱ --:--

💡 Инструкция: Выберите один ответ из пяти. На 25 вопросов отведено 70 минут. В заданиях с кодом учитывайте указанную конструкцию и не додумывайте отсутствующие условия. После завершения откроются общий результат, тематические шкалы и разбор каждого ответа.

Вопрос 1 из 25

Что делает CancellationToken сам по себе?

Немедленно завершает поток Передаёт сигнал отмены, на который код должен добровольно отреагировать Освобождает все ресурсы Токен сам прерывает текущую инструкцию после Cancel Принудительно завершает связанную Task без участия выполняемого кода

Вопрос 2 из 25

Как корректно проверить токен в CPU-цикле?

for (var i = 0; i < items.Length; i++)
{
    if ((i & 1023) == 0) token.ThrowIfCancellationRequested();
    Process(items[i]);
}

Сравнивать token с null Создать новый token на каждой итерации Периодически вызвать token.ThrowIfCancellationRequested() Прерывать поток извне вместо совместной проверки токена Проверять токен только после завершения всего цикла

Вопрос 3 из 25

Почему токен нужно передать в ReadAsync?

var read = await stream.ReadAsync(buffer, token);

Для выбора кодировки Чтобы поток стал background Иначе чтение станет синхронным Отмена должна прерывать само ожидание ввода-вывода Передать токен, чтобы отмена автоматически вызвала Dispose у самого Stream

Вопрос 4 из 25

Кто должен Dispose-ить CancellationTokenSource?

Каждая зависимость CTS освобождается средой после доставки отмены, владелец не нужен Освобождать источник в каждом методе, который получил созданный из него Token Полагаться на финализатор CancellationTokenSource вместо явного владения Код, который создал источник и владеет его жизненным циклом

Вопрос 5 из 25

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

using var registration = token.Register(() => socket.Dispose());
await ReceiveUntilClosedAsync();

Ловить все исключения молча Изменить token.IsCancellationRequested Запустить бесконечный Task.Run Подписаться на static event без отписки token.Register с последующим Dispose регистрации

Вопрос 6 из 25

Что вернёт Task.WhenAll для Task<int>[]?

Первый результат Массив результатов в порядке входных задач Dictionary по идентификатору потока Количество успешно завершившихся задач без их результатов Результаты в порядке завершения

Вопрос 7 из 25

Запущены ли операции конкурентно в этом примере?

var a = LoadAAsync(token);
var b = LoadBAsync(token);
await Task.WhenAll(a, b);

Да, оба async-метода вызваны до общего await Только если есть Task.Run Операции станут конкурентными только после оптимизации Release-сборки Нет, Task не запускается до Result Нет, WhenAll вызывает их по одной

Вопрос 8 из 25

Что произойдёт с итоговой задачей Task.WhenAll, если одна из входных задач завершилась ошибкой?

Остальные потоки немедленно убиваются Ошибка превратится в false WhenAll вернёт null для сбойной задачи и завершится успешно Первая задача перезапустится Итог будет faulted; остальные задачи сами не отменятся

Вопрос 9 из 25

Какой результат у await Task.WhenAll(Array.Empty<Task>())?

await Task.WhenAll(Array.Empty<Task>());
Console.WriteLine("done");

Немедленное успешное завершение Новый поток Отменённая задача Исключение Бесконечное ожидание

Вопрос 10 из 25

Как ограничить 10 одновременных вызовов для тысячи элементов?

await Parallel.ForEachAsync(ids,
    new ParallelOptions { MaxDegreeOfParallelism = 10, CancellationToken = token },
    async (id, ct) => await client.LoadAsync(id, ct));

Обернуть каждый сетевой вызов в общий lock Увеличить минимальное число потоков вместо ограничения запросов Создать тысячу Task.Run и положиться только на размер пула потоков Ожидать каждый вызов последовательно, полностью отказавшись от конкурентности Задать MaxDegreeOfParallelism = 10 в ParallelOptions

Вопрос 11 из 25

Что делает cts.CancelAfter(TimeSpan.FromSeconds(2))?

using var cts = new CancellationTokenSource();
cts.CancelAfter(TimeSpan.FromSeconds(2));
await WorkAsync(cts.Token);

Запросит отмену примерно через две секунды После двух секунд повторит операцию с тем же токеном Гарантированно убивает операцию Задерживает запуск на две секунды Меняет системные часы

Вопрос 12 из 25

Чем WaitAsync(timeout) отличается от передачи токена самой операции?

WaitAsync закрывает underlying socket при таймауте WaitAsync повторяет исходную операцию после таймаута с новым внутренним токеном WaitAsync прекращает ожидание, но не обязательно саму операцию WaitAsync доступен только ValueTask и не применяется к обычному Task Различий нет: прекращение ожидания гарантированно отменяет нижележащую операцию

Вопрос 13 из 25

Как различить таймаут сервиса и отмену пользователем?

using var timeout = new CancellationTokenSource(limit);
using var linked = CancellationTokenSource.CreateLinkedTokenSource(
    requestToken, timeout.Token);
try { await CallAsync(linked.Token); }
catch (OperationCanceledException) when (timeout.IsCancellationRequested && !requestToken.IsCancellationRequested)
{ throw new TimeoutException(); }

Сравнить текст исключения Считать обе ситуации ошибкой 500 Разделить источники отмены и проверить сработавший Считать каждый OperationCanceledException внутренним таймаутом сервиса Проверить идентификатор потока

Вопрос 14 из 25

Почему одинаковый 30-секундный таймаут на каждом из трёх последовательных вызовов нарушает общий SLA 30 секунд?

CancelAfter работает только один раз на процесс Среда распределит общий таймаут между дочерними вызовами Второй вызов не запустится Таймауты складываются и цепочка может занять около 90 секунд SLA учитывает только вычислительное время сервиса

Вопрос 15 из 25

Что сделать с задачей, проигравшей Task.WhenAny delay?

var operation = RunAsync(cts.Token);
if (await Task.WhenAny(operation, Task.Delay(timeout)) != operation)
{
    cts.Cancel();
    try { await operation; } catch (OperationCanceledException) { }
    throw new TimeoutException();
}

Забыть ссылку Запустить её повторно Отменить проигравшую задачу и дождаться её Считать её успешной Принудительно остановить поток, на котором выполняется проигравшая задача

Вопрос 16 из 25

Когда разумен результат ItemResult<T> вместо исключения всего batch?

Когда исключения запрещены языком Чтобы не вести журнал Когда каждый элемент независим и контракт допускает частичный успех ItemResult нужен и для одного элемента, чтобы не использовать exceptions Когда нужно скрыть системный сбой

Вопрос 17 из 25

Почему catch { return null; } опасен в fan-out?

async Task<Customer?> LoadSafe(Guid id)
{
    try
    {
        return await client.LoadAsync(id);
    }
    catch
    {
        return null;
    }
}

Конструкция catch запрещена внутри асинхронного метода Task.WhenAll удалит из результата все задачи, вернувшие null После catch среда сама повторяет исходный запрос без ограничения Теряется причина, а нормальное отсутствие данных неотличимо от сбоя Возврат null автоматически переводит Task в состояние Faulted

Вопрос 18 из 25

Когда retry POST может создать дубль?

POST без idempotency key безопасно повторять после timeout Если операция неидемпотентна и первый ответ потерялся после успешной обработки Когда запрос выполняется через await: ожидание само делает операцию повторяемой Когда небольшое тело запроса помещается в один сетевой пакет и отправляется повторно При повторе GET без ключа идемпотентности, даже если операция не изменяет состояние

Вопрос 19 из 25

Что требуется для all-or-nothing между независимыми внешними сервисами без общей транзакции?

Task.WhenAll гарантирует rollback Оркестрация saga/компенсации и устойчивое состояние шагов Параллельно запустить компенсации без проверки идемпотентности Только Serializable в локальной базе Обычный lock процесса

Вопрос 20 из 25

Как собрать исход каждой задачи без прерывания обработки первой ошибкой?

async Task<Result<T>> Capture<T>(Func<Task<T>> call)
{
    try { return Result.Success(await call()); }
    catch (Exception ex) { return Result.Failure<T>(ex); }
}
var results = await Task.WhenAll(calls.Select(Capture));

Использовать async void Ловить AggregateException и выбросить её После первой ошибки отменить остальные задачи и не собирать их исходы Вызвать WaitAll на UI-потоке Пусть каждая задача возвращает Success или Failure

Вопрос 21 из 25

Как детерминированно проверить отмену операции?

var entered = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously);
var dependency = new FakeDependency(entered);
var task = sut.RunAsync(cts.Token);
await entered.Task;
cts.Cancel();
await Assert.ThrowsAnyAsync<OperationCanceledException>(() => task);

Запустить тест пять раз Заблокировать зависимость, отменить и проверить токен Thread.Sleep и надеяться Считать IsCancellationRequested до запуска Подобрать таймаут, превышающий обычное время входа в зависимость

Вопрос 22 из 25

Что полезно измерять у fan-out?

Единичный снимок памяти процесса без связи с размером партии и текущей конкурентностью Общее число созданных Task без размера партии и числа одновременно активных операций Количество операторов await и длину имён задач как приближение сложности fan-out Одно среднее время без перцентилей и разделения успешных, ошибочных и отменённых исходов Размер партии, фактическую конкурентность, длительность и исходы: успех, ошибка или отмена

Вопрос 23 из 25

Как проверить общий deadline без ожидания реального времени?

var time = new FakeTimeProvider();
var task = sut.RunAsync(time, token);
time.Advance(TimeSpan.FromSeconds(30));
await Assert.ThrowsAsync<TimeoutException>(() => task);

Использовать Stopwatch.StartNew только Подменить TimeProvider и продвинуть виртуальное время Уменьшить timeout до 1 мс и надеяться Ждать полный реальный срок в каждом тестовом запуске Изменить системные часы машины

Вопрос 24 из 25

Почему отмену клиента и внутренний таймаут стоит размечать разными метками?

У них разные причины и действия: уход клиента не равен деградации зависимости Клиентская отмена и таймаут имеют разные типы Task Чтобы отключить retry Считать обе причины одним видом отмены без отдельной метки Чтобы увеличить число метрик

Вопрос 25 из 25

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

await Assert.ThrowsAsync<TimeoutException>(() => sut.FetchAsync());
await fake.WaitUntilIdleAsync();
Assert.Equal(0, fake.ActiveCalls);

Проверить только тип исключения Проверить лишь число потоков после завершения теста Проверить лишь освобождение управляемой памяти после таймаута После сценария счётчик активных операций равен нулю Проверить лог один раз

Ответьте на все 25 вопросов, чтобы получить результат

🔗 Встроить тест на свой сайт (iframe) ▼

Скопируйте код и вставьте в любое место на вашем сайте:

Также доступна прямая ссылка на embed-страницу