如何理解使用std :: memory_order_acquire调用compare_exchange_strong

Question

从C ++并发操作7.2.5中引述-将内存模型应用于无锁堆栈。

这些下面的代码摘自本书。而且我知道只有一个弹出线程会很好。但是，如果有两个线程弹出，而没有关于释放顺序的规则，那么使用memory_order_acquire可以安全吗。

就我而言，我需要用memory_order_acq_rel替换memory_order_acquire，这将导致两个弹出线程之间的同步。但是书上说memory_order_acquire就足够了。

我对memory_order_acquire的理解是否错误：获取和释放不需要配对？

template<typename T>
class lock_free_stack
{
    void increase_head_count(counted_node_ptr& old_counter)
    {
        counted_node_ptr new_counter;
        do
        {
            new_counter=old_counter;
            ++new_counter.external_count;
        }

        // problem here
        while(!head.compare_exchange_strong(old_counter,new_counter
            ,std::memory_order_acquire,std::memory_order_relaxed));

        old_counter.external_count=new_counter.external_count;
    }

    std::shared_ptr<T> pop()
    {
        counted_node_ptr old_head=head.load();
        for(;;)
        {
            // call
            increase_head_count(old_head);

            node* const ptr=old_head.ptr;
            if(!ptr)
            {
                 return std::shared_ptr<T>();
            }
            if(head.compare_exchange_strong(old_head,ptr->next))
            {
                 // todo delete
            }
            else if(ptr->internal_count.fetch_sub(1)==1)
            {
                delete ptr;
            }
        }
    }
}