C++ threadsafe环缓冲区实现

Question

我正在C++中进行多线程编程，我在想C++中是否有线程安全的环形缓冲区实现，或者您是否知道如何实现它。

Answer 1

这是一个基本的实现。要求存储在缓冲区中的对象是默认可构造的，并且是可复制的（通过将它们存储在std :: vector <>中）。需要C++11支持（对于std::atomic）。几乎所有最近gcc版本将具有它与-std=c++11或-std=c++0x

如果c++11不可用，用正确的编译器的内部制作head_和tail_原子。

对于一个阅读器线程和一个写入器线程应该是安全的。通过调用

auto val = ringbuffer.back(); 
    val = some_value; 
    ringbuffer.push(); 

Retreive项目：

通过调用发布项目

auto val = ringbuffer.front(); 
    // do stuff with val 
    ringbuffer.pop(); 

如果back()回报nullptr，那么缓冲区 “满”。如果front()返回nullptr那么缓冲区是“空的”。

警告，未测试（全部）：d

#include <vector> 

    template <class T> 
    class RingBuffer 
    { 
    public: 
    RingBuffer(size_t buffer_size) 
     : ring_(buffer_size) 
     , buffer_size_(buffer_size) 
     , head_(0) 
     , tail_(0) 
    { 
    } 

    T* back() 
    { 
     bool received = false; 

     if(available(head_, tail_)) 
     { 
      return &(ring_[head_ % buffer_size_]); 
     } 

     return nullptr; 
    } 

    void push() 
    { 
     ++head_; 
    } 

    T* front() 
    { 
     if(tail_ < head_) 
     { 
      return & ring_[tail_ % buffer_size_]; 
     } 

     return nullptr; 
    } 

    void pop() 
    { 
     ++tail_; 
    } 

    size_t size() const 
    { 
     if(tail_ < head_) 
      return buffer_size_ - ((tail_ + buffer_size_) - head_); 
     else if(tail_ > head_) 
      return buffer_size_ - (tail_ - head_); 

     return 0; 
    } 

    bool available() 
    { 
     return available(head_, tail_); 
    } 

    private: 
    bool available(uint64_t h, uint64_t t) const 
    { 
     if(h == t) 
      return true; 
     else if(t > h) 
      return (t - h) > buffer_size_; 
     else// if(h > t) 
      return (t + buffer_size_) - h > 0; 
    } 

    std::vector<T> ring_; 
    const size_t buffer_size_; 
    std::atomic<uint64_t> head_; 
    std::atomic<uint64_t> tail_; 
    }; 

Answer 2

http://www.boost.org/doc/libs/1_61_0/doc/html/boost/lockfree/spsc_queue.html可能是你在找什么