安全的消费者 - 生产者无锁环形缓冲

Question

假设：

• sizeof(T)小于或等于sizeof(uint64_t)
• T已对齐
• 目标平台是x86和x86-64
• 只有一个生产者线程（只允许调用push_back和完整）
• 只有一个消费者帖子（只允许拨打pop_front和empty）
• ArraySimple是一个动态分配的数组，具有固定大小（指针+大小）

约束：

• 消费者线程不得阻止

问题：以下RingBuffer安全吗？如果没有，我可以添加的最少的东西是确保消费者阅读的数据混淆不清。

    template<class T>
    class RingBuffer
        {
        public:
            explicit RingBuffer(size_t N):
                m_offset_read(0),m_offset_write(0),m_data(N)
                {}

            void push_back(T x)
                {
                auto owr=m_offset_write;
                m_data[owr]=x;
                uint32_t N=length();
                m_offset_write=(owr+1)%N;
                }

            T pop_front()
                {
                auto ore=m_offset_read;
                auto ret=m_data[ore];
                uint32_t N=length();
                m_offset_read=(ore+1)%N;
                return ret;
                }

            bool full() const
                {return m_offset_write < m_offset_read;}

            bool empty() const
                {return m_offset_read==m_offset_write;}

            uint32_t length() const noexcept
                {return m_data.length();}

        private:
            volatile uint32_t m_offset_read;
            volatile uint32_t m_offset_write;
            ArraySimple<T> m_data;
        };