Ранний сброс hazard pointer

        std::atomic<void*>& hp = get_hazard_pointer_for_current_thread();
        node* old_head = head.load();
 
        do {
            node* temp;
            do {    // Keep looping until you know that the head pointer still has the same value you set your hazard pointer to
                temp = old_head;
                hp.store(old_head);
                old_head = head.load();
            } while (old_head != temp);
        } while (old_head && !head.compare_exchange_strong(old_head, old_head->next));
        hp.store(nullptr);  // Once the object is no longer needed, the hazard pointer is cleared
        
        std::shared_ptr<T> res;
        if (old_head) {
            res.swap(old_head->data);

//
// Lock-free версия list.pop().
//
std::shared_ptr<T> pop()
{
    //
    // Получаем hazard pointer для текущего потока.
    //
    std::atomic<void*>& hp=get_hazard_pointer_for_current_thread();
    
    //
    // Получаем адрес элемента, который находится в голове списка.
    //
    node* old_head=head.load();
    
    //
    // Здесь нужно атомарно сделать две вещи: во-первых, записать указатель
    // на головной элемент списка в hazard pointer, временно защитив его от
    // удаления, а во-вторых, извлечь этот элемент из списка, передвинув
    // указатель head->next на следующий элемент.
    //
    // Внутренний цикл решает первую проблему, внешний - вторую.
    //
    // Защита от удаления элемента с помощью hazard pointer только для
    // того и нужна, чтобы иметь возможность безопасно выполнить
    // compare_exchange_strong(old_head,old_head->next). Другие потоки по
    // окончанию работы проверяют hazard pointers и делают delete объекту
    // только если на него не осталось ссылок (см. ниже)
    //
    
    do
    {
        node* temp;
        do 
        {
            temp=old_head;
            hp.store(old_head); // Временно запрещаем удаление.
            old_head=head.load();
        } while(old_head!=temp);
    }
    while(old_head &&
        !head.compare_exchange_strong(old_head,old_head->next)); // Пытаемся удалить
                           // элемент из списка.
        
    //
    // Если мы попали сюда, значит, мы достигли следующего:
    // 1. old_head удален из списка и head.load() в другом потоке
    // будет возвращать уже другое значение.
    // 2. hazard pointer все еще удерживает элемент от удаления.
    //
    
    //
    // Удерживать элемент дальше нет смысла, т.к. на него ни у кого
    // не осталось ссылок. Поэтому обнуляем hazard pointer.
    //
    hp.store(nullptr);
    
    //
    // Получаем данные из извлеченного элемента списка.
    //
    
    std::shared_ptr<T> res;
    if(old_head)
    {
        res.swap(old_head->data);
        
        //
        // Неочевидный момент.
        // Другой поток в данное время может находиться внутри циклов do/while и
        // выполнять compare_exchange_strong(old_head,old_head->next) с данным
        // указателем, поэтому сразу вызывать delete не безопасно.
        //
        
        if(outstanding_hazard_pointers_for(old_head)) 
        {
            reclaim_later(old_head); 
        }
        else
        {
            delete old_head; 
        }
        delete_nodes_with_no_hazards(); 
    }
    return res;
}