C++无锁循环缓冲实现

#ifndef min

#define min(a,b) (((a) < (b)) ? (a) : (b))

#endif

#ifndef max

#define max(a,b) (((a) > (b)) ? (a) : (b))

#endif

// 无锁缓冲队列.

class circular_buffer

{

public:

   circular_buffer(int buf_size)

      : m_buffer_size(buf_size)

      , m_circle_buffer(NULL)

      , m_write_p(0)

      , m_read_p(0)

   {

      m_circle_buffer = new char[m_buffer_size];

   }

   ~circular_buffer()

   {

      if (m_circle_buffer)

         delete[] m_circle_buffer;

      m_circle_buffer = NULL;

   }

   void clear()

   {

      m_write_p = 0;

      m_read_p = 0;

   }

   unsigned int available()

   {

      return m_buffer_size - (m_write_p - m_read_p);

   }

   unsigned int used()

   {

      return m_write_p - m_read_p;

   }

   unsigned int put_data(char* buffer, unsigned int len)

   {

      unsigned int l;

      len = _min(len, m_buffer_size - m_write_p + m_read_p);

      /* first put the data starting from fifo->in to buffer end */

      l = _min(len, m_buffer_size - (m_write_p & (m_buffer_size - 1)));

      memcpy(m_circle_buffer + (m_write_p & (m_buffer_size - 1)), buffer, l);

      /* then put the rest (if any) at the beginning of the buffer */

      memcpy(m_circle_buffer, buffer + l, len - l);

      m_write_p += len;

      return len;

   }

   unsigned int get_data(char* buffer, unsigned int len)

   {

      unsigned int l;

      len = _min(len, m_write_p - m_read_p);

      /* first get the data from fifo->out until the end of the buffer */

      l = _min(len, m_buffer_size - (m_read_p & (m_buffer_size - 1)));

      memcpy(buffer, m_circle_buffer + (m_read_p & (m_buffer_size - 1)), l);

      /* then get the rest (if any) from the beginning of the buffer */

      memcpy(buffer + l, m_circle_buffer, len - l);

      m_read_p += len;

      return len;

   }

protected:

   inline unsigned int _max(unsigned int a, unsigned int b)

   {

      return max(a, b);

   }

   inline unsigned int _min(unsigned int a, unsigned int b)

   {

      return min(a, b);

   }

private:

   int m_buffer_size;

   char* m_circle_buffer;

   unsigned int m_write_p;

   unsigned int m_read_p;

};