std::hazard_pointer

Hazard pointer — это слот, видимый всем потокам, в который читающий поток записывает адрес объекта непосредственно перед тем, как его разыменовать. Пока адрес там записан, любой другой поток, желающий освободить память по этому адресу, обязан отложить освобождение ("retire" вместо немедленного delete) и повторно проверить это позже. Это способ безопасного управления памятью для lock-free структур без сборщика мусора и без атомарного подсчёта ссылок на каждый узел.A hazard pointer is a slot, visible to all threads, into which a reading thread writes the address of an object right before dereferencing it. As long as that address is recorded there, any other thread wanting to free memory at that address must defer the free ("retire" instead of an immediate delete) and re-check later. This is a way to manage memory safely in lock-free structures with no garbage collector and no atomic reference count per node.

std::atomic<Node*> head;

// получить hazard pointer и опубликовать защиту текущего head// obtain a hazard pointer and publish protection of the current head
auto hp = std::hazard_pointer_obtain();
Node* node = hp.protect(head);   // теперь безопасно разыменовать node — его никто не освободит, пока hp жив// now safe to dereference node — nobody will free it while hp is alive

if (node) {
    use(*node);                // безопасное чтение под защитой// a safe read under protection
}
// hp выходит из области видимости — защита снимается автоматически// hp goes out of scope — protection is lifted automatically

Lock-free структуры данных страдают одной фундаментальной проблемой, которую hazard_pointer решает раз и навсегда на уровне стандарта:Lock-free data structures suffer from one fundamental problem, which hazard_pointer solves once and for all at the standard-library level:

std::hazard_pointer_obtain() берёт hazard pointer из внутреннего пула потока. Метод .protect(atomic_ptr) атомарно читает atomic_ptr, публикует прочитанный адрес как защищённый, и перечитывает atomic_ptr ещё раз, чтобы убедиться, что значение не изменилось между чтением и публикацией (иначе цикл повторяется). После этого разыменование прочитанного указателя безопасно. Удаляющая сторона вызывает не delete напрямую, а retire() — объект попадает в список отложенных на удаление, и реальное удаление происходит только тогда, когда сканирование всех активных hazard pointers подтвердит, что ни один из них не защищает этот адрес.std::hazard_pointer_obtain() takes a hazard pointer from a thread-local internal pool. The .protect(atomic_ptr) method atomically reads atomic_ptr, publishes the read address as protected, and re-reads atomic_ptr once more to confirm the value hasn't changed between the read and the publish (otherwise the loop repeats). After that, dereferencing the read pointer is safe. The deleting side doesn't call delete directly but retire() — the object goes onto a list of pending deletions, and the actual deletion happens only once a scan of all active hazard pointers confirms none of them protects that address.

struct Node { int value; std::atomic<Node*> next; };

void remove_and_retire(std::atomic<Node*>& slot, Node* old_node) {
    slot.store(old_node->next.load());
    // не delete напрямую — retire откладывает удаление до безопасного момента// not a direct delete — retire defers deletion until it's safe
    std::hazard_pointer_retire(old_node, [](Node* p) { delete p; });
}

• WG21 P2530 — Hazard Pointers for C++26
• cppreference — hazard_pointer