C++ 线程安全环缓冲区实现

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();

通过调用检索项目：

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

如果back()返回一个nullptr，则缓冲区为"full"。 如果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_;
  };