无锁堆栈-这是c++11宽松原子的正确用法吗?它能被证明吗

我为一个非常简单的数据段编写了一个容器，该数据段需要跨线程同步。我想要最好的表演。我不想用锁

我想使用"放松的"原子。一方面是因为那一点点额外的魅力，另一方面是为了真正理解它们

我已经在这方面做了很多工作，我已经到了这个代码通过所有测试的地步。不过这还不是很"证明"，所以我想知道我是否遗漏了什么，或者我可以用其他方法来测试它？

这是我的前提：

• 重要的是，节点被正确地推送和弹出，并且堆栈永远不会无效
• 我相信记忆中的操作顺序只有一个地方很重要：
  • compare_exchange操作本身之间<这是有保证的，即使是宽松的原子论>
• "ABA"问题是通过在指针上添加识别号来解决的。在32位系统上，这需要一个双字compare_exchange，而在64位系统中，指针的未使用的16位用id号填充
• 因此：堆栈将始终处于有效状态 (对吗？(

以下是我的想法。"通常"，我们对正在阅读的代码进行推理的方式是查看代码的编写顺序。内存可以被读取或写入"无序"，但不能以使程序正确性无效的方式读取或写入。

这在多线程环境中会发生变化。这就是内存围栏的作用——这样我们仍然可以查看代码，并能够推理它将如何工作。

所以，如果这里的一切都可能出了问题，我该怎么处理放松的原子论呢？这不是有点太远了吗？

我不这么认为，但这就是我来这里寻求帮助的原因。

compare_exchange操作本身保证了彼此之间的序列恒定性

对原子进行读取或写入的唯一其他时间是在compare_exchange之前获取头的初始值。它被设置为变量初始化的一部分。据我所知，这一操作是否能带来"适当"的价值是无关紧要的。

当前代码：

struct node
{
    node *n_;
#if PROCESSOR_BITS == 64
    inline constexpr node() : n_{ nullptr }                 { }
    inline constexpr node(node* n) : n_{ n }                { }
    inline void tag(const stack_tag_t t)                    { reinterpret_cast<stack_tag_t*>(this)[3] = t; }
    inline stack_tag_t read_tag()                           { return reinterpret_cast<stack_tag_t*>(this)[3]; }
    inline void clear_pointer()                             { tag(0); }
#elif PROCESSOR_BITS == 32
    stack_tag_t t_;
    inline constexpr node() : n_{ nullptr }, t_{ 0 }        { }
    inline constexpr node(node* n) : n_{ n }, t_{ 0 }       { }
    inline void tag(const stack_tag_t t)                    { t_ = t; }
    inline stack_tag_t read_tag()                           { return t_; }
    inline void clear_pointer()                             { }
#endif
    inline void set(node* n, const stack_tag_t t)           { n_ = n; tag(t); }
};
using std::memory_order_relaxed;
class stack
{
public:
    constexpr stack() : head_{}{}
    void push(node* n)
    {
        node next{n}, head{head_.load(memory_order_relaxed)};
        do
        {
            n->n_ = head.n_;
            next.tag(head.read_tag() + 1);
        } while (!head_.compare_exchange_weak(head, next, memory_order_relaxed, memory_order_relaxed));
    }
    bool pop(node*& n)
    {
        node clean, next, head{head_.load(memory_order_relaxed)};
        do
        {
            clean.set(head.n_, 0);
            if (!clean.n_)
                return false;
            next.set(clean.n_->n_, head.read_tag() + 1);
        } while (!head_.compare_exchange_weak(head, next, memory_order_relaxed, memory_order_relaxed));
        n = clean.n_;
        return true;
    }
protected:
    std::atomic<node> head_;
};

这个问题与其他问题相比有什么不同？放松的原子。他们对这个问题有很大的不同。

那么，你觉得呢？我缺什么了吗？

void push(Node* node) noexcept
{
    Node* n = _head.next();
    do {
        node->setNext(n);
    } while (!_head.compareAndSwap(n, node));
}