Многопоточность

Атомарная операция завершается без видимого промежуточного состояния — другие потоки видят её как полностью выполненную или не начатую. std::atomic<T> делает load, store, fetch_add и compare_exchange неделимыми.

Используйте RAII-обёртки — никогда lock()/unlock() вручную: lock_guard простейший, unique_lock мобильный и нужен для condition_variable, scoped_lock (C++17) захватывает несколько мьютексов атомарно.

Гонка данных — конкурентный доступ к одной памяти с хотя бы одной записью без синхронизации — UB. Состояние гонки — более широкий баг: корректность зависит от планирования. Критическая секция должна выполняться атомарно.

Mutex с lock_guard/unique_lock для защиты общих данных; condition_variable для producer-consumer; std::atomic для одной переменной; std::promise/future для однократной передачи.

Если объект std::thread остаётся joinable в момент работы деструктора, программа немедленно вызывает std::terminate(). Нужно явно вызвать join или detach до уничтожения.

C++ гарантирует конкурентное чтение одного объекта, конкурентные вызовы на разных объектах одного типа, операции std::atomic и потокобезопасную инициализацию static-локальных (C++11). Конкурентные чтение+запись одного не-атомарного объекта — гонка данных и UB.

Захватите unique_lock и вызовите cv.wait(lock, predicate) — он атомарно освобождает блокировку и блокируется. При notify поток повторно захватывает блокировку и проверяет предикат. Spurious wakeup — wait вернулся без notify.

Deadlock — когда потоки бесконечно ждут друг друга, обычно из-за захвата мьютексов в разном порядке. Предотвращают единым порядком захвата, короткими scope и std::scoped_lock для нескольких мьютексов.

Мьютексы, блокировки (lock_guard/unique_lock/scoped_lock), condition_variable, атомики и C++20 latch/barrier/semaphore. lock_guard — простейшая RAII-обёртка: блокирует при конструировании, освобождает при уничтожении.

Concurrency — структурирование программы так, чтобы задачи продвигались в пересекающиеся промежутки времени. Parallelism — буквально одновременное выполнение задач на разных ядрах. Concurrent может работать параллельно, но не обязан.

Мьютекс имеет владельца — освободить может только захвативший. Семафор — сигнальный примитив со счётчиком; сигналить может любой поток. C++20 добавляет std::counting_semaphore/binary_semaphore.

launch::async запускает задачу сразу в новом потоке; launch::deferred лениво — в вызывающем потоке при get(). Умолчание может молча оказаться deferred, а деструктор future блокирует при async.

Многопоточность запускает потоки ОС параллельно на ядрах. Асинхронность стартует задачу и получает результат позже, возможно в том же потоке через event loop. Потоки — физический параллелизм.

Конкурентные чтения безопасны; любая конкурентная запись — гонка данных. front() + pop_front() — гонка TOCTOU: поток A держит ссылку, а B вызывает pop_front() и уничтожает элемент.

std::counting_semaphore (C++20) хранит счётчик, поэтому допускает до N одновременных держателей, а не одного. У него нет владельца — любой поток может вызвать release() для пермита, захваченного другим потоком, что подходит для межпоточной сигнализации и пулов ресурсов.

C++11 добавил std::thread, мьютексы, condition_variable, атомики, future/async. C++17 — shared_mutex и параллельный STL. C++20 — jthread, latch, barrier, semaphore, корутины.

Гонка данных: ++counter — несинхронизированная операция «чтение-изменение-запись» между потоками, что является неопределённым поведением, поэтому итоговое значение непредсказуемо. Решение: std::atomic<int> counter{0} (тогда ++counter атомарен) или защитить инкремент std::mutex + lock_guard.

std::jthread автоматически делает join в деструкторе (без terminate() если забыл) и интегрируется с std::stop_token для кооперативной отмены через request_stop() и stop_requested().

Оба (C++20) заставляют потоки ждать, пока счётчик не дойдёт до нуля. std::latch одноразовый: уменьшили счётчик раз — и он исчерпан. std::barrier переиспользуемый: каждый arrive_and_wait сбрасывает его к следующей фазе и запускает completion-функцию между фазами.

Дедлок из-за инверсии порядка блокировок: t1 захватывает m1, затем m2; t2 — m2, затем m1. Если каждый возьмёт свой первый мьютекс одновременно, второй не достанется никому. Решение: захватывать в одном глобальном порядке или std::scoped_lock lk(m1, m2) (C++17), запирающий оба атомарно.

Определяет, когда записи одного потока видимы другому через std::atomic с упорядочиваниями (seq_cst, acq_rel, relaxed) и отношением happens-before. До C++11 переносимой модели потоков не было.

Mutex используйте для защиты инвариантов на нескольких операциях или переменных. Atomic — для простого независимого состояния: счётчиков, флагов. Atomic не делает сложную логику автоматически безопасной.

std::recursive_mutex позволяет одному потоку захватывать блокировку много раз без дедлока. lock() увеличивает внутренний счётчик, unlock() уменьшает; мьютекс освобождается на нуле.

std::shared_mutex (C++17) имеет shared-режим (чтение) для многих потоков и exclusive-режим (запись) для одного. std::shared_lock для чтения, std::unique_lock для записи.

Для нескольких мьютексов std::scoped_lock (C++17) вызывает std::lock — алгоритм избегания дедлока: он пробует, откатывается и повторяет при конфликте, поэтому фиксированный порядок захвата не нужен. Затем держит их в стиле RAII и освобождает все в деструкторе.

Спинлок ждёт в цикле, не уступая CPU, и избегает накладных расходов syscall на сон/пробуждение мьютекса. Быстрее мьютекса только при очень короткой критической секции; на длинной — тратит CPU впустую.

Исключение, покидающее функцию std::thread, вызывает std::terminate. Для передачи между потоками используйте std::future/std::async (перебрасывается на get()) или std::exception_ptr для ручного захвата.

Заранее создайте N рабочих, ожидающих общей очереди задач, защищённой мьютексом и condition variable. submit() кладёт std::function<void()> и будит один поток; деструктор ставит флаг остановки и делает join.

Ограниченная очередь под мьютексом с двумя CV: not_full (производитель ждёт при полной) и not_empty (потребитель ждёт при пустой). Грейсфул через флаг done_ — потребители дренируют по done_ && queue_.empty().

thread_local даёт каждому потоку собственную независимую копию переменной, инициализируемую при первом обращении и уничтожаемую при завершении потока.

std::atomic<T> делает RMW-операции неделимыми. Упорядочивания: relaxed, acquire/release, acq_rel и seq_cst (полный глобальный порядок, по умолчанию).

Минимальная Atomic<T> оборачивает значение и мьютекс с load/store/compare_exchange_strong. Настоящий std::atomic<T> для тривиально-копируемых типов использует lock-free инструкции CPU через intrinsic — без мьютекса.

Нет. Блокировка flock() принадлежит описанию открытого файла, а не потоку. Все потоки одного процесса разделяют этот fd, поэтому видят одну и ту же блокировку, и flock() никогда не блокирует один поток против другого. Это рекомендательная блокировка между процессами; для потоков используйте std::mutex.

Deadlock: потоки зависли в ожидании друг друга, прогресса нет. Livelock: потоки работают и меняют состояние в ответ друг другу, но полезной работы нет — обычно от наивной retry-логики без jitter.

CPU-bound задачи: один поток на логическое ядро (hardware_concurrency()); I/O-bound: больше потоков, чем ядер, так как они в основном ждут; закон Амдала ограничивает ускорение последовательной долей.

ABA: compare_exchange читает A, другой поток меняет его на B и обратно на A, поэтому CAS проходит, хотя структура под ним изменилась. Борются тегированным указателем (счётчик версии, растущий при каждом обновлении) или hazard pointers.

Double-checked locking читает ленивый указатель без lock, затем под lock проверяет повторно. До C++11 — UB: поток мог увидеть ненулевой указатель при неинициализированных полях.

False sharing — когда два потока пишут в разные переменные, попавшие на одну кэш-линию: каждая запись инвалидирует копию у другого ядра, вызывая ping-pong линии. Лечится выравниванием горячих данных на std::hardware_destructive_interference_size.

atomic_thread_fence(order) — самостоятельный барьер, упорядочивающий предыдущие и последующие операции в текущем потоке без атомарной загрузки или записи. Обычно проще задать release/acquire прямо на атомарной операции.

Lock-free: хотя бы один поток всегда продвигается (дедлок невозможен, но отдельные потоки могут голодать). Wait-free: каждый поток завершает за ограниченное число шагов — самая сильная гарантия.

Барьер памяти запрещает переупорядочивание операций через него. Acquire (загрузка): последующие операции остаются после; release (сохранение): предыдущие — до. Пара release/acquire делает прежние записи писателя видимыми читателю.

Высокоприоритетный поток ждёт lock у низкоприоритетного, а среднеприоритетные вытесняют держателя. Митигируется priority inheritance, priority ceiling или короткими критическими секциями.

Минимизируйте разделяемое изменяемое состояние, явно документируйте гарантии потокобезопасности, инкапсулируйте RAII-блокировки на границах класса, не удерживайте блокировку при вызове колбэков и открывайте атомарные составные операции вместо отдельных check/act.