std::atomic::compare_exchange 与两个 memory_order 参数一起使用的真实示例

Question

您能否给出一个真实世界的例子，其中使用 std::atomic::compare_exchange 的两个 memory_order 参数版本是有原因的（所以一个 memory_order 参数版本是不够的）？

Answer 1

在许多情况下，compare_exchange 上的第二个内存排序参数设置为 memory_order_relaxed。在这些情况下，省略它通常并没有错，只是可能效率较低。

这是一个简单的无锁 list/stack 示例，它需要 compare_exchange_weak 上的第二个不同的排序参数才能避免数据争用。

对push的调用可以并发执行，但为了避免无锁数据操作的复杂性，假设在执行对 push 的调用时无法从堆栈中删除节点；即避免悬挂指针。

template<typename T>
class mystack {

    struct node {
        node *next = nullptr;

        T data;
        int id;

        node(int id) : id{id} { }
    };

    std::atomic<node *> head{nullptr};

public:
    void push(T data, int id);
    bool pop(T &data); // not implemented
};


template<typename T>
void mystack<T>::push(T data, int id)
{
    node *newnode = new node{id};

    newnode->data = std::move(data);

    node *current_head = head.load(std::memory_order_relaxed);   // A

    for (;;)
    {
        newnode->next = current_head;

        if (head.compare_exchange_weak(current_head, newnode,
                                       std::memory_order_release,   // B
                                       std::memory_order_acquire))  // C
        {
            /*
             * 'current_head' may not be derefenced here since the initial load (at A)
             * does not order memory 'current_head' is pointing at.
             *
             * a release barrier (at B) is necessary to make 'newnode' available
             * to other threads
             */
            std::cout << "Insertion successful\n";

            break;

        } else
        {
            /*
             * 'current_head' is the updated head pointer after 'compare_exchange' failed
             * Since it was inserted by another thread (the CAS failed),
             * an acquire barrier must be set (at C) in order to be able to access data
             * 'current_head' is pointing at.
             */
            std::cout << "Insertion failed after head changed to id: " <<
                          current_head->id << std::endl;
        }
    }
}

在push中，最初的load（在A处）是一个宽松的操作，这意味着即使head指针是原子加载的，它可能不会被取消引用，因为它引用的内存在该线程中是无序的。

如果 compare_exchange_weak returns 成功，newnode 被插入列表的头部，并通过设置释放屏障（在 B 处）使其他线程可用。访问此数据的另一个线程（稍后，通过 pop）需要设置获取屏障。

万一 compare_exchange_weak returns 失败（虚假地忘记了），另一个线程刚刚插入了一个新的 node 实例并且 current_head 被更新为 [= 的新值18=]。由于 current_head 现在指向在另一个线程中分配和释放的数据，如果要取消引用 current_head，则需要获取屏障。
这是真的，因为 cout 失败消息包括 current_head->id。

如果省略最后一个参数，第一个屏障参数将用于失败 load 场景，但由于这是一个释放屏障，有效屏障会衰减到 memory_order_relaxed，导致 current_head->id.

上的数据竞争

std::atomic::compare_exchange 与两个 memory_order 参数一起使用的真实示例

Real-world example where std::atomic::compare_exchange used with two memory_order parameters

c++

multithreading

atomic