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

Допустимо ли использовать memory_order_release для атомарной загрузки?

При замене memory_order_acquire на memory_order_consume в загрузке указателя какие данные гарантированно видит поток?

После замены std::mutex на std::shared_mutex почему запись может начать голодать?

В старом интерфейсе поле нельзя заменить на std::atomic без изменения ABI. Что нужно обеспечить, чтобы безопасно использовать его через std::atomic_ref?

Можно ли считать один лишь release-фенс средством публикации обычных данных другому потоку?

После замены join на detach какое ограничение возникает для времени жизни объектов, к которым обращается поток?

Ситуация: несколько потоков получают доступ к лениво инициализируемому объекту. Безопасно ли читать value после успешного std::call_once, не делая его атомарным?

#include <mutex>
#include <thread>

std::once_flag flag;
int value;

void init() {
    value = 42;
}

int read() {
    std::call_once(flag, init);
    return value;
}

Допустим, производитель публикует данные через release-барьер, а потребитель читает их после acquire-барьера: при каком условии такая схема создаёт отношение happens-before?

Гарантируют ли два атомарных поля согласованный снимок состояния при чтении из другого потока?

В многопоточном коде флаг объявлен как volatile: почему это не делает остановку рабочего потока безопасной?

Оцените выбор порядка памяти для неудачной попытки compare_exchange: может ли он быть release?

В ситуации, где два потока захватывают общие мьютексы в разном порядке, какое условие приводит к взаимной блокировке?

При последовательных relaxed-загрузках одной атомарной переменной может ли второй результат относиться к более старой записи, чем первый?

Поток уже завершился, но объект std::thread остаётся joinable. Что произойдёт при его уничтожении?

Как release- и acquire-барьеры могут обеспечить видимость обычных данных между потоками через одну атомарную переменную?

В следующем фрагменте уведомление выполняется до запуска ожидающего потока. Объясните, почему ожидание не теряется и при каком условии wait возвращается.

#include <atomic>
#include <thread>

std::atomic<bool> ready{false};

void worker() {
    ready.wait(false);
}

int main() {
    ready.store(true, std::memory_order_release);
    ready.notify_one();
    std::thread t(worker);
    t.join();
}

После создания std::thread новый поток читает обычные данные, записанные до создания потока. Почему это может быть безопасно без атомика?

Разбор последствий: какую ошибку вызывает проблема ABA в lock-free структуре данных?

Каким образом операция RMW с порядком relaxed может продолжить release-последовательность атомика?

При разработке lock-free счётчика почему одиночная попытка compare_exchange_weak может привести к ошибке, даже если значение не изменилось?