Question

我正在尝试编写在两侧堆栈上均无边界的线程安全实现。
在size操作中，我需要将capacity与if (size == cap) { return; } // append element进行比较，如果它们不相等，则为堆栈设置新的head元素。
真正的方法是什么？
如果我写

#include <atomic>
#include <boost/next_prior.hpp>
#include <boost/lockfree/spsc_queue.hpp>
#include <boost/function.hpp>

template<typename T>
struct Node
{
    Node(const T& data)
        :data(data), next(nullptr) {}

public:
    T data;

    Node* next;
};

template <typename T>
class Stack {
    using WriteCallback = typename std::function<void (const T&)>;
    using ReadCallback  = typename std::function<void (T&&)>;

    template<typename T1>
    using queue = boost::lockfree::spsc_queue<T1>;

public:
    Stack(int cap)
        :head(nullptr),
         size(0),
         cap(cap),
         onWrite(0),
         onRead(0)
    {}

    void push(const T& val, WriteCallback cb)
    {
        if (size == cap) {
            onWrite.push(cb);
            return;
        }
        // insertion will be here
    }

private:
    Node* head;

    std::atomic<int> size;
    std::atomic<int> cap;

    queue<WriteCallback> onWrite;
    queue<ReadCallback>  onRead;
};

我不确定比较之后其他线程不会立即将最后一个值压入堆栈。

api

Answer 1

您是否正在寻找原子compare and swap？

如果编译器可用，则可以使用C11中的atomic_compare_exchange，或者使用与系统和编译器相关的lock cmpxchg内在函数。

例如，对于msvc：https://msdn.microsoft.com/en-us/library/ttk2z1ws.aspx

编辑：刚在C ++ 11中找到它：std::atomic::compare_exchange_weak / std::atomic::compare_exchange_strong？

原子比较

1 个答案: