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

Потоки и синхронизация

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

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

⏱ --:--

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

Вопрос 1 из 25

Что делает Thread.Start?

var thread = new Thread(() => Console.Write("worker"));
thread.Start();
thread.Join();

Выполняет делегат на вызывающем потоке Создаёт Task без потока Блокирует до завершения Запускает делегат на новом системном потоке Отменяет текущий поток

Вопрос 2 из 25

Чем background thread отличается при завершении процесса?

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

Вопрос 3 из 25

Почему Thread.Sleep не делает I/O масштабируемым?

Thread.Sleep(1000);       // поток занят ожиданием
await Task.Delay(1000);     // поток может обслужить другую работу

Sleep создаёт слишком много Task Он освобождает все locks Он превращает код в async Он работает только в UI Sleep удерживает бездействующий поток

Вопрос 4 из 25

Когда выделенный Thread может быть оправдан?

Для долгоживущего цикла с привязкой к потоку или особыми настройками Thread Для чтения файла через ReadAsync вместо ожидания задачи Для отдельного потока на каждый входящий HTTP-запрос Для каждого периодического таймера приложения Чтобы выполнить обычный запрос LINQ к коллекции

Вопрос 5 из 25

Почему сбой RunLoop нельзя наблюдать через Task, создавшую этот поток?

var thread = new Thread(RunLoop);
thread.Start();

Среда перезапустит поток с той же точки после исключения Переданное исключение будет заменено значением null Вызов Join перехватит и вернёт исключение вызывающему коду У Thread нет контракта Task; необработанное исключение может завершить процесс Thread автоматически прикрепляется к последней созданной Task

Вопрос 6 из 25

Что гарантирует lock для одного gate?

В секции одновременно находится не более одного потока, синхронизирующегося на том же gate Весь метод атомарен, даже если часть кода использует другой объект синхронизации Блокировка действует между разными процессами и машинами Все участники выполняются параллельно внутри критической секции Любая взаимная блокировка автоматически обнаруживается и отменяется

Вопрос 7 из 25

Почему gate обычно private readonly object?

private readonly object _gate = new();

public void Add(Item item)
{
    lock (_gate) _items.Add(item);
}

Чтобы gate попал на стек Чтобы разрешить await Внешний код не должен разделять тот же монитор Потому что lock работает только с object Чтобы монитор автоматически обслуживал ожидающие потоки в порядке очереди

Вопрос 8 из 25

Можно ли написать await внутри lock?

Только с ConfigureAwait(false) Да, если Task завершён Нет; нужен SemaphoreSlim или асинхронная блокировка Да, монитор освобождается на время await Только для static gate

Вопрос 9 из 25

Почему lock(this) опасен в публичном классе?

public void Update()
{
    lock (this)
    {
        Recalculate();
    }
}

Внешний код способен захватить тот же монитор и вмешаться в порядок блокировок Использование this в lock запрещает наследование класса Ссылка this внутри метода экземпляра может внезапно стать null После lock объект автоматически становится неизменяемым Мониторы работают только со структурами, но не с классами

Вопрос 10 из 25

Что означает reentrant lock в .NET?

Один поток может повторно войти в Monitor того же объекта, увеличив счётчик владения Два разных потока могут одновременно войти в один Monitor без ожидания Повторный lock рекурсивно блокирует все поля объекта После первого выхода Monitor нельзя захватить повторно тем же потоком Повторный вход отменяет исключения, возникшие внутри предыдущего блока lock

Вопрос 11 из 25

Что означает new SemaphoreSlim(3, 3)?

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

Вопрос 12 из 25

Почему Release должен быть в finally?

await gate.WaitAsync(token);
try
{
    await UseResourceAsync(token);
}
finally
{
    gate.Release();
}

Чтобы увеличить максимум Вернуть разрешение при любом исключении Чтобы отменить token Чтобы выполнить его до WaitAsync Чтобы задача стала cold

Вопрос 13 из 25

Чем SemaphoreSlim(1,1) отличается от lock в async-коде?

WaitAsync сам отменяет защищаемую операцию при ожидании SemaphoreSlim синхронизирует процессы по имени Он не требует Release Он быстрее при любых условиях Он позволяет WaitAsync без блокировки потока во время ожидания

Вопрос 14 из 25

Что случится при лишнем Release сверх maxCount?

var gate = new SemaphoreSlim(1, 1);
gate.Release(); // начальный счётчик уже равен максимуму

Семафор расширит максимум Счётчик станет отрицательным Все ожидающие отменятся Будет SemaphoreFullException Счётчик останется равным maxCount, а лишний Release будет проигнорирован

Вопрос 15 из 25

Как ограничить обращения к API, но не держать разрешение во время локальной обработки ответа?

Response response;
await apiGate.WaitAsync(token);
try { response = await api.CallAsync(token); }
finally { apiGate.Release(); }
return Parse(response);

Использовать static lock на весь процесс Отпустить семафор сразу после сетевого вызова Держать permit до завершения всей обработки, чтобы сохранить порядок Release до WaitAsync Создать semaphore на каждый вызов

Вопрос 16 из 25

Почему counter++ теряет обновления?

Parallel.For(0, 100_000, _ => counter++);

counter++ — отдельные чтение, сложение и запись Инкремент запрещён в потоках Переполнение int вызывает потерю обновлений между потоками Потоки выполняются строго последовательно Добавление volatile сделало бы составную операцию counter++ атомарной

Вопрос 17 из 25

Как атомарно увеличить int?

volatile counter++ Interlocked.Increment(ref counter) Thread.Sleep(0) Task.Yield lock(new object())

Вопрос 18 из 25

Почему ContainsKey затем TryAdd не образуют единую атомарную проверку?

ConcurrentDictionary не поддерживает пользовательские ключи ContainsKey и TryAdd выполняются в разных процессах ОС Между вызовами другой поток может вставить ключ; нужен результат TryAdd или GetOrAdd TryAdd всегда выбрасывает исключение при существующем ключе ContainsKey удаляет найденный ключ перед следующим вызовом

Вопрос 19 из 25

Может ли factory в ConcurrentDictionary.GetOrAdd выполниться несколько раз для одного ключа?

var value = cache.GetOrAdd(key, _ => CreateExpensive());

Да, лишь когда сама factory использует изменяемое состояние без синхронизации Нет: контракт гарантирует единственный вызов factory на ключ даже при гонке потоков Да, но только для null-ключа, который несколько потоков одновременно нормализуют Да, но в словарь попадёт только одно значение Нет: factory вызывается после атомарного добавления и получает уже сохранённое значение

Вопрос 20 из 25

Что решает volatile для поля?

Создаёт взаимное исключение для всех обращений к полю Запрещает сборщику мусора перемещать объект с этим полем Делает составную последовательность чтения и записи атомарной Переносит поле в неуправляемую память и отключает кэш процессора Задаёт правила видимости и порядка для поля, но не делает counter++ атомарным

Вопрос 21 из 25

Как сделать окно гонки воспроизводимым?

var barrier = new Barrier(2);
Task Worker() => Task.Run(() => {
    var observed = value;
    barrier.SignalAndWait();
    value = observed + 1;
});

Добавить фиксированные Sleep перед общей записью в каждом потоке Сравнить логи после падения Свести потоки Barrier-ом перед общей записью Отключить оптимизацию Запустить на одном потоке

Вопрос 22 из 25

Что измерять у блокировки под нагрузкой?

Количество полей класса, внутри которого находится lock Число исключений сборщика мусора во время теста Только количество созданных объектов синхронизации Время ожидания, длительность удержания и число конкурирующих участников Длину имени объекта, используемого в lock

Вопрос 23 из 25

Как диагностировать deadlock процесса .NET?

dotnet-dump collect -p <pid> -o deadlock.dmp
dotnet-dump analyze deadlock.dmp
# В анализаторе: clrthreads, clrstack, syncblk

Сохранить список потоков без стеков и считать одинаковые имена доказательством взаимной блокировки Найти последний оператор lock в исходниках без сопоставления с фактическим состоянием процесса Снять только счётчики CPU и GC: цикл ожиданий будет однозначно виден по их значениям Снять dump и изучить стеки потоков, мониторы и цепочки ожиданий Увеличить минимальное число потоков; исчезновение симптома само по себе подтвердит deadlock

Вопрос 24 из 25

Почему тест только на ConcurrentDictionary недостаточен для операции перевода денег?

ConcurrentDictionary выполняет операции только в одном потоке Асинхронный метод автоматически делает перевод атомарным Использование ConcurrentDictionary запрещает дополнительные блокировки Инвариант затрагивает несколько ключей и шагов, которые коллекция не объединяет в транзакцию Словарь не поддерживает значения типа decimal

Вопрос 25 из 25

Какой стресс-тест полезен после детерминированного?

for (var run = 0; run < 1_000; run++)
{
    var account = new Account(1_000);
    await RunConcurrentTransfers(account);
    Assert.Equal(1_000, account.TotalAcrossBuckets);
}

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

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

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

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

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