最近在做网络数据收发操作时，用到环形缓冲区的数据结构，网上看了很多人的实现方式，总觉得不妥，于是决定自己亲自写一个，适用于自己的项目。

先看一张关于环形队列的描述图（如下），它是一种FIFO（先入先出）的队列，其明确队列的容量，存储结构上表现为头尾相连，使用起始位置和结束位置标识队列节点的存储区段。

avatar

更多关于环形队列的描述，这里就不再重复，可至 环形缓冲器(FIFO) 查看。

我给出相关代码的结构定义如下：

  1. /**
  2.  * @struct x_ringbuf_t
  3.  * @brief  环形缓存的结构体描述信息。
  4.  */
  5. typedef struct x_ringbuf_t
  6. {
  7.     x_uint32_t   xut_vpos;  ///< 缓存中有效数据的起始位置
  8.     x_uint32_t   xut_vlen;  ///< 缓存中有效数据的长度
  9.     x_uint32_t   xut_size;  ///< 缓存大小
  10.     x_uchar_t  * xct_dptr;  ///< 缓存地址
  11. } x_ringbuf_t;

从上面的结构体定义中，可以看出，数据区段的结束位置，使用了数据区段的长度来替换了，这样做，可避免 起始位置 与 结束位置 重叠在一起时，表示不清 环形缓存 是 满区段 还是 空区段。

  1. /** 判断环形缓存是否有效 */
  2. #define RBUF_IS_VALID(xrbt_sptr)   ((X_NULL != (xrbt_sptr)) && \
  3.                                     (X_NULL != (xrbt_sptr)->xct_dptr) && ((xrbt_sptr)->xut_size > 0) && \
  4.                                     ((xrbt_sptr)->xut_vpos >= 0) && ((xrbt_sptr)->xut_vpos < (xrbt_sptr)->xut_size) && \
  5.                                     ((xrbt_sptr)->xut_vlen <= (xrbt_sptr)->xut_size))
  7. /** 判断环形缓存是否为 空 */
  8. #define RBUF_IS_EMPTY(xrbt_sptr)   (0 == (xrbt_sptr)->xut_vlen)
  10. /** 判断环形缓存是否为 满 */
  11. #define RBUF_IS_FULL(xrbt_sptr)    ((xrbt_sptr)->xut_size == (xrbt_sptr)->xut_vlen)
  13. /**********************************************************/
  14. /**
  15.  * @brief 用于 环形缓存的内存申请操作 回调函数类型（内存要释放时，请调用 xfunc_ringbuf_free 指向的接口）。
  16.  * 
  17.  * @param [in ] xht_context : 回调的上下文描述句柄。
  18.  * @param [in ] xut_size    : 提交申请的内存字节数。
  19.  * 
  20.  * @return x_uchar_t *
  21.  *         - 操作成功，返回申请到的内存地址；
  22.  *         - 操作失败，返回 X_NULL。
  23.  */
  24. typedef x_uchar_t * (* xfunc_ringbuf_malloc)(x_handle_t xht_context, x_uint32_t xut_size);
  26. /**********************************************************/
  27. /**
  28.  * @brief 用于 环形缓存的内存释放操作 回调函数类型（所释放的内存，即为 xfunc_ringbuf_malloc 所申请的）。
  29.  *
  30.  * @param [in ] xht_context : 回调的上下文描述句柄。
  31.  * @param [in ] xpvt_ptr    : 要释放的内存地址。
  32.  * 
  33.  */
  34. typedef x_void_t (* xfunc_ringbuf_free)(x_handle_t xht_context, x_void_t * xpvt_ptr);
  36. /**********************************************************/
  37. /**
  38.  * @brief 创建 环形缓存对象（使用 rbuf_destroy() 接口进行对象销毁）。
  39.  * 
  40.  * @param [in ] xut_size    : 环形缓存 的缓存大小。
  41.  * @param [in ] xfunc_mptr  : 内存申请操作的回调函数接口（若为 X_NULL，则使用标准 C 的 malloc() 接口进行分配内存）。
  42.  * @param [in ] xht_context : 回调的上下文描述句柄。
  43.  * 
  44.  * @return x_ringbuf_t *
  45.  *         - 操作成功，返回 环形缓存 对象；
  46.  *         - 操作失败，返回  X_NULL。
  47.  */
  48. x_ringbuf_t * rbuf_create(x_uint32_t xut_size, xfunc_ringbuf_malloc xfunc_mptr, x_handle_t xht_context);
  50. /**********************************************************/
  51. /**
  52.  * @brief 销毁 环形缓存对象（由 rbuf_create() 接口创建的对象）。
  53.  * 
  54.  * @param [in ] xrbt_sptr   : 环形缓存对象。
  55.  * @param [in ] xfunc_fptr  : 内存释放操作的回调函数接口（若为 X_NULL，则使用标准 C 的 free() 接口进行释放内存）。
  56.  * @param [in ] xht_context : 回调的上下文描述句柄。
  57.  * 
  58.  */
  59. x_void_t rbuf_destroy(x_ringbuf_t * xrbt_sptr, xfunc_ringbuf_free xfunc_fptr, x_handle_t xht_context);
  61. /**********************************************************/
  62. /**
  63.  * @brief 读取环形缓存对象中的有效数据至指定的缓存中；
  64.  *        该操作后，会修改环形缓存中的有效数据相关字段。
  65.  * 
  66.  * @param [in ] xrbt_sptr : 环形缓存对象。
  67.  * @param [out] xct_rptr  : 指定的数据接收缓存。
  68.  * @param [in ] xut_size  : 数据接收缓存大小。
  69.  * 
  70.  * @return x_uint32_t
  71.  *         - 返回读取到的有效数据量（字节数）。
  72.  */
  73. x_uint32_t rbuf_read(x_ringbuf_t * xrbt_sptr, x_uchar_t * xct_rptr, x_uint32_t xut_size);
  75. /**********************************************************/
  76. /**
  77.  * @brief 向环形缓存对象写入数据；
  78.  *        环形缓存剩余的空间量必须足够待写入的数据量，否则直接返回 0，忽略后续操作；
  79.  *        该操作后，会修改环形缓存中的有效数据相关字段。
  80.  * 
  81.  * @param [out] xrbt_sptr : 环形缓存对象。
  82.  * @param [in ] xct_wptr  : 待写入数据的缓存。
  83.  * @param [in ] xut_size  : 待写入数据的缓存大小。
  84.  * 
  85.  * @return x_uint32_t
  86.  *         - 返回写入的有效数据量（字节数）。
  87.  */
  88. x_uint32_t rbuf_write(x_ringbuf_t * xrbt_sptr, const x_uchar_t * xct_wptr, x_uint32_t xut_size);
  90. /**********************************************************/
  91. /**
  92.  * @brief 抹除环形缓存中的头部数据。
  93.  *
  94.  * @param [out] xrbt_sptr  : 环形缓存对象。
  95.  * @param [in ] xut_count  : 请求抹除的字节数。
  96.  *
  97.  * @return x_uint32_t
  98.  *         - 返回抹除的字节数。
  99.  */
  100. x_uint32_t rbuf_erase_head(x_ringbuf_t * xrbt_sptr, x_uint32_t xut_count);
  102. /**********************************************************/
  103. /**
  104.  * @brief 抹除环形缓存中的尾部数据。
  105.  *
  106.  * @param [out] xrbt_sptr  : 环形缓存对象。
  107.  * @param [in ] xut_count  : 请求抹除的字节数。
  108.  *
  109.  * @return x_uint32_t
  110.  *         - 返回抹除的字节数。
  111.  */
  112. x_uint32_t rbuf_erase_tail(x_ringbuf_t * xrbt_sptr, x_uint32_t xut_count);

对于 rbuf_create() 与 rbuf_destroy() 中加入了 内存 申请/释放 的回调操作函数 的参数，这样方便外部介入内存管理操作（使用内存池进行内存的分配与释放操作）。

  1. /**********************************************************/
  2. /**
  3.  * @brief 创建 环形缓存对象（使用 rbuf_destroy() 接口进行对象销毁）。
  4.  *
  5.  * @param [in ] xut_size    : 环形缓存 的缓存大小。
  6.  * @param [in ] xfunc_mptr  : 内存申请操作的回调函数接口（若为 X_NULL，则使用标准 C 的 malloc() 接口进行分配内存）。
  7.  * @param [in ] xht_context : 回调的上下文描述句柄。
  8.  *
  9.  * @return x_ringbuf_t *
  10.  *         - 操作成功，返回 环形缓存 对象；
  11.  *         - 操作失败，返回  X_NULL。
  12.  */
  13. x_ringbuf_t * rbuf_create(x_uint32_t xut_size, xfunc_ringbuf_malloc xfunc_mptr, x_handle_t xht_context)
  14. {
  15.     x_ringbuf_t * xrbt_sptr = X_NULL;
  16.     if (xut_size <= 0)
  17.     {
  18.         return X_NULL;
  19.     }
  21.     if (X_NULL == xfunc_mptr)
  22.     {
  23.         xrbt_sptr = (x_ringbuf_t *)malloc(sizeof(x_ringbuf_t) + xut_size);
  24.     }
  25.     else
  26.     {
  27.         xrbt_sptr = (x_ringbuf_t *)xfunc_mptr(xht_context, sizeof(x_ringbuf_t) + xut_size);
  28.     }
  30.     if (X_NULL != xrbt_sptr)
  31.     {
  32.         xrbt_sptr->xut_vpos = 0;
  33.         xrbt_sptr->xut_vlen = 0;
  34.         xrbt_sptr->xut_size = xut_size;
  35.         xrbt_sptr->xct_dptr = ((x_uchar_t *)xrbt_sptr) + sizeof(x_ringbuf_t);
  36.     }
  38.     return xrbt_sptr;
  39. }
  41. /**********************************************************/
  42. /**
  43.  * @brief 销毁 环形缓存对象（由 rbuf_create() 接口创建的对象）。
  44.  *
  45.  * @param [in ] xrbt_sptr   : 环形缓存对象。
  46.  * @param [in ] xfunc_fptr  : 内存释放操作的回调函数接口（若为 X_NULL，则使用标准 C 的 free() 接口进行分配内存）。
  47.  * @param [in ] xht_context : 回调的上下文描述句柄。
  48.  *
  49.  */
  50. x_void_t rbuf_destroy(x_ringbuf_t * xrbt_sptr, xfunc_ringbuf_free xfunc_fptr, x_handle_t xht_context)
  51. {
  52.     if (X_NULL != xrbt_sptr)
  53.     {
  54.         if (X_NULL == xfunc_fptr)
  55.         {
  56.             free(xrbt_sptr);
  57.         }
  58.         else
  59.         {
  60.             xfunc_fptr(xht_context, (x_void_t *)xrbt_sptr);
  61.         }
  62.     }
  63. }
  65. /**********************************************************/
  66. /**
  67.  * @brief 读取环形缓存对象中的有效数据至指定的缓存中；
  68.  *        该操作后，会修改环形缓存中的有效数据相关字段。
  69.  *
  70.  * @param [in ] xrbt_sptr : 环形缓存对象。
  71.  * @param [out] xct_rptr  : 指定的数据接收缓存。
  72.  * @param [in ] xut_size  : 数据接收缓存大小。
  73.  *
  74.  * @return x_uint32_t
  75.  *         - 返回读取到的有效数据量（字节数）。
  76.  */
  77. x_uint32_t rbuf_read(x_ringbuf_t * xrbt_sptr, x_uchar_t * xct_rptr, x_uint32_t xut_size)
  78. {
  79.     x_uint32_t xut_rbytes = 0;
  80.     x_uint32_t xut_cbytes = 0;
  82.     XASSERT(RBUF_IS_VALID(xrbt_sptr));
  83.     XASSERT((0 == xut_size) || ((xut_size > 0) && (X_NULL != xct_dptr)));
  85.     if ((xut_size <= 0) || (xrbt_sptr->xut_vlen <= 0))
  86.     {
  87.         return 0;
  88.     }
  90.     xut_rbytes = (xut_size >= xrbt_sptr->xut_vlen) ? xrbt_sptr->xut_vlen : xut_size;
  92.     if ((xrbt_sptr->xut_vpos + xut_rbytes) <= xrbt_sptr->xut_size)
  93.     {
  94.         memcpy(xct_rptr, xrbt_sptr->xct_dptr + xrbt_sptr->xut_vpos, xut_rbytes);
  95.     }
  96.     else
  97.     {
  98.         xut_cbytes = xrbt_sptr->xut_size - xrbt_sptr->xut_vpos;
  99.         memcpy(xct_rptr, xrbt_sptr->xct_dptr + xrbt_sptr->xut_vpos, xut_cbytes);
  100.         memcpy(xct_rptr + xut_cbytes, xrbt_sptr->xct_dptr, xut_rbytes - xut_cbytes);
  101.     }
  103.     xrbt_sptr->xut_vlen -= xut_rbytes;
  104.     if (0 == xrbt_sptr->xut_vlen)
  105.         xrbt_sptr->xut_vpos = 0;
  106.     else
  107.         xrbt_sptr->xut_vpos = (xrbt_sptr->xut_vpos + xut_rbytes) % xrbt_sptr->xut_size;
  109.     return xut_rbytes;
  110. }
  112. /**********************************************************/
  113. /**
  114.  * @brief 向环形缓存对象写入数据；
  115.  *        环形缓存剩余的空间量必须足够待写入的数据量，否则直接返回 0，忽略后续操作；
  116.  *        该操作后，会修改环形缓存中的有效数据相关字段。
  117.  *
  118.  * @param [out] xrbt_sptr : 环形缓存对象。
  119.  * @param [in ] xct_wptr  : 待写入数据的缓存。
  120.  * @param [in ] xut_size  : 待写入数据的缓存大小。
  121.  *
  122.  * @return x_uint32_t
  123.  *         - 返回写入的有效数据量（字节数）。
  124.  */
  125. x_uint32_t rbuf_write(x_ringbuf_t * xrbt_sptr, const x_uchar_t * xct_wptr, x_uint32_t xut_size)
  126. {
  127.     x_uint32_t xut_wpos = 0;
  128.     x_uint32_t xut_wlen = 0;
  130.     XASSERT(RBUF_IS_VALID(xrbt_sptr));
  131.     XASSERT((0 == xut_size) || ((xut_size > 0) && (X_NULL != xct_wptr)));
  133.     if ((xut_size <= 0) || (xut_size > (xrbt_sptr->xut_size - xrbt_sptr->xut_vlen)))
  134.     {
  135.         return 0;
  136.     }
  138.     xut_wpos = (xrbt_sptr->xut_vpos + xrbt_sptr->xut_vlen) % xrbt_sptr->xut_size;
  140.     if ((xut_wpos + xut_size) <= xrbt_sptr->xut_size)
  141.     {
  142.         memcpy(xrbt_sptr->xct_dptr + xut_wpos, xct_wptr, xut_size);
  143.     }
  144.     else
  145.     {
  146.         xut_wlen = xrbt_sptr->xut_size - xut_wpos;
  147.         memcpy(xrbt_sptr->xct_dptr + xut_wpos, xct_wptr, xut_wlen);
  148.         memcpy(xrbt_sptr->xct_dptr, xct_wptr + xut_wlen, xut_size - xut_wlen);
  149.     }
  151.     xrbt_sptr->xut_vlen += xut_size;
  153.     return xut_size;
  154. }
  156. /**********************************************************/
  157. /**
  158.  * @brief 抹除环形缓存中的头部数据。
  159.  *
  160.  * @param [out] xrbt_sptr  : 环形缓存对象。
  161.  * @param [in ] xut_count  : 请求抹除的字节数。
  162.  *
  163.  * @return x_uint32_t
  164.  *         - 返回抹除的字节数。
  165.  */
  166. x_uint32_t rbuf_erase_head(x_ringbuf_t * xrbt_sptr, x_uint32_t xut_count)
  167. {
  168.     x_uint32_t xut_bytes = 0;
  170.     XASSERT(RBUF_IS_VALID(xrbt_sptr));
  172.     if (xut_count <= 0)
  173.     {
  174.         return 0;
  175.     }
  177.     if (xut_count >= xrbt_sptr->xut_vlen)
  178.     {
  179.         xut_bytes = xrbt_sptr->xut_vlen;
  181.         xrbt_sptr->xut_vpos = 0;
  182.         xrbt_sptr->xut_vlen = 0;
  183.     }
  184.     else
  185.     {
  186.         xut_bytes = xut_count;
  188.         xrbt_sptr->xut_vpos = (xrbt_sptr->xut_vpos + xut_count) % xrbt_sptr->xut_size;
  189.         xrbt_sptr->xut_vlen -= xut_count;
  190.     }
  192.     return xut_bytes;
  193. }
  195. /**********************************************************/
  196. /**
  197.  * @brief 抹除环形缓存中的尾部数据。
  198.  *
  199.  * @param [out] xrbt_sptr  : 环形缓存对象。
  200.  * @param [in ] xut_count  : 请求抹除的字节数。
  201.  *
  202.  * @return x_uint32_t
  203.  *         - 返回抹除的字节数。
  204.  */
  205. x_uint32_t rbuf_erase_tail(x_ringbuf_t * xrbt_sptr, x_uint32_t xut_count)
  206. {
  207.     x_uint32_t xut_bytes = 0;
  209.     XASSERT(RBUF_IS_VALID(xrbt_sptr));
  211.     if (xut_count <= 0)
  212.     {
  213.         return 0;
  214.     }
  216.     if (xut_count >= xrbt_sptr->xut_vlen)
  217.     {
  218.         xut_bytes = xrbt_sptr->xut_vlen;
  220.         xrbt_sptr->xut_vpos = 0;
  221.         xrbt_sptr->xut_vlen = 0;
  222.     }
  223.     else
  224.     {
  225.         xut_bytes = xut_count;
  227.         xrbt_sptr->xut_vlen -= xut_count;
  228.     }
  230.     return xut_bytes;
  231. }

ring_buffer: https://github.com/Gaaagaa/ring_buffer

无锁环形队列的一种高效实现：https://www.cnblogs.com/dodng/p/4367791.html

版权声明：本文为VxGaaagaa原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://www.cnblogs.com/VxGaaagaa/p/10012842.html