Базовый CS с нуля
Время и конкурентность: тест с выбором ответа
Суть Тест с выбором на синтез по всему юниту — async, blocking vs non-blocking, event loop, concurrency vs parallelism и race conditions, появляющиеся, когда задачи делят общее состояние.
Высота — путь к senior
НольJuniorMiddleSenior
Ты на middle-высоте — в небеШесть вопросов поперёк всего юнита. Каждый — это предсказание или решение о реально работающей программе: не определение для заучивания, а рассуждение, к которому вели уроки, доведённое на шаг дальше — туда, где задачи делят общее состояние.
Цель
Убедись, что связываешь спину юнита — зачем существует async, blocking vs non-blocking, единственное правило event loop и concurrency vs parallelism — и рассуждаешь о том, что происходит, когда переплетённые или параллельные задачи трогают одни и те же данные.
Викторина
Completed
Веб-сервер читает файл с диска на каждый запрос. Переход с blocking-чтения на non-blocking делает само чтение с диска насколько долгим и что реально улучшается?
Heads-up Non-blocking ничего не меняет в устройстве. Диск всё равно тратит свои 10 мс. Меняется лишь то, заморожен ли CPU на время ожидания (blocking) или свободен делать другую работу (non-blocking).
Heads-up Они ведут себя очень по-разному. Blocking-вызов держит свой кадр стека застрявшим, пока работа не закончится, замораживая программу; non-blocking-вызов возвращается сразу и доставляет результат позже через callback.
Heads-up Он не падает. Non-blocking-вызов передаёт запрос устройству и сразу возвращается; результат доставляется позже через callback, когда устройство закончит.
Викторина
Completed
Программа выполняет: console.log('A'); setTimeout(cb, 0), где cb печатает 'B'; затем console.log('C'). Что она печатает и какое правило за этим стоит?
Heads-up 0 задаёт задержку постановки в очередь, а не время запуска. B кладётся в callback queue, но event loop не запустит его, пока call stack не опустеет — а это происходит только после того, как синхронные A и C напечатаны.
Heads-up Callback'и никогда не вытесняют синхронный код. Callback в очереди ждёт опустошения стека; синхронный код всегда завершается первым. Нет приоритета, который позволил бы callback прервать выполняющуюся строку.
Heads-up Event loop однопоточный — одно ядро, одно дело за раз. B поздний из-за правила пустого стека, а не потому что выполнялся на другом ядре. Здесь ничто не идёт параллельно.
Викторина
Completed
Программа устроена как одна задача с одним thread. Ты запускаешь её на 16-ядерной машине. Насколько она быстра и почему?
Heads-up Один thread — это один упорядоченный поток инструкций, его нельзя разбить по ядрам. Лишние ядра простаивают, пока программа не структурирована в несколько thread'ов или задач. Структура должна предшествовать parallelism.
Heads-up Больше ядер сами по себе никогда не делают программу параллельной. Parallelism требует, чтобы работа была сначала разбита на несколько задач; программа с одной задачей и одним thread выполняется на одном ядре, сколько бы их ни было.
Heads-up Одна задача использует одно ядро; остальные 15 просто не используются, а не координируются. Накладных расходов нет, потому что нечего координировать — программа ровно так же быстра, как на одноядерной машине.
Викторина
Completed
Одноядерная машина переплетает 50 задач через event loop. Сколько выполняется в один и тот же момент и это concurrency или parallelism?
Heads-up Concurrency значит чередование по очереди, а не настоящую одновременность. Одно ядро — это один fetch-decode-execute движок, и выполняет ровно одну инструкцию за раз. В любой момент реально выполняется лишь одна из 50 задач.
Heads-up Event loop — это concurrency, а не parallelism. Он выполняет один callback до конца, прежде чем начать следующий, всё на одном ядре. Parallelism требует нескольких ядер; event loop на одном ядре никогда не имеет двух задач, выполняющихся в один момент.
Heads-up Переплетение значит, что одна выполняется, пока остальные ждут своей очереди. В каждый момент ровно одна задача исполняется на ядре; остальные приостановлены, а не все остановлены.
Викторина
Completed
Два thread'а на двух ядрах каждый выполняет counter = counter + 1 миллион раз над одним общим counter, без synchronization. Итоговое значение часто гораздо ниже двух миллионов. Почему?
Heads-up counter = counter + 1 не атомарен — это чтение, сложение и запись. Два thread'а могут переплестись между этими подшагами, оба прочитать одно значение, и одна запись затирает другую. Потерянные обновления реальны, а не ошибка измерения.
Heads-up Оба ядра могут читать и писать одну общую память — именно в этом проблема. Ничего не отвергается; обновления теряются, потому что два чтения одного старого значения ведут к двум записям одного нового значения, тогда как должно быть два разных инкремента.
Heads-up Event loop — это однопоточная concurrency. Здесь сценарий — два реальных thread'а на двух ядрах, идущих параллельно: нет единого event loop, сериализующего их. Именно настоящий параллельный доступ к общему состоянию делает race возможным.
Викторина
Completed
Команда добавила lock, чтобы только один thread мог выполнять обновление counter за раз. Race исчез, но throughput упал на 8-ядерной машине. Как это читать?
Heads-up Ни один lock не может и то, и другое. Lock работает именно тем, что заставляет thread'ы проходить через защищённую секцию по очереди, что по определению последовательно. Цена throughput — это плата за корректность; снижают её, блокируя меньше, а не ожидая, что lock пойдёт параллельно.
Heads-up У lock есть реальная стоимость: он превращает параллельную секцию в последовательную, поэтому thread'ы стоят в очереди за ним. Чем больше времени внутри lock, тем меньше parallelism остаётся. Замедление — прямое и ожидаемое следствие блокировки.
Heads-up Убрать lock — значит сразу вернуть race; больше ядер делают race хуже, а не лучше, потому что больше thread'ов борются за одни незащищённые данные. Правильный рычаг — минимизировать общую заблокированную область, сохраняя lock для корректности.
Итог
Сквозная линия юнита — одна идея, доведённая до края: CPU быстр, а устройства медленны, поэтому программы используют async — non-blocking-вызовы плюс callback’и — и event loop, выполняющий один callback за раз, только когда call stack пуст. Это concurrency: много задач переплетены на одном ядре, по очереди. Parallelism — иное: задачи по-настоящему выполняются в один и тот же момент на нескольких ядрах — и помогает только когда работа структурирована в задачи. Как только эти задачи делят состояние, становится возможен race condition: шаг вроде counter = counter + 1 на деле чтение-сложение-запись, и параллельные thread’ы могут переплестись и потерять обновления. Lock восстанавливает корректность, сериализуя общую секцию — ценой того самого parallelism, который он защищает. Сначала корректность, затем минимизируй то, что должно быть последовательным.