单向循环链表实现RingBuffer

Posted 2021-11-23 fulianzhou

        一般我们用的RingBuffer都是用数组或vector实现，用读指针与写指针来控制RingBuffer的输入与输出。用不同的线程来Push与Pull，一般情况下这种结构是非常高效的，无需加锁。但是当Pull处理线程比Push处理线程慢得多的时候，Push就会等待RingBuffer非空；等待有时候会很耗费时间，运行的越久累积的时延就越高。

        所以用单向循环链表来替代数组或vector，当RingBuffer满时就插入一个新的位置，减少Push等待时间。但是如果Pull处理的时间太长，Push又不断有新数据插入，就会导致RingBuffer太长，占用过多资源，所以可以加一个计数器来控制RingBuffer的最大长度。

listringbuffer.h

#ifndef _LIST_RINGBUFFER_H_
#define _LIST_RINGBUFFER_H_
#include <stdint.h>


template <typename T>
struct LNode
{
    T data;
    LNode* next;

    LNode() :next(NULL){}
    LNode(const T& item) : next(NULL), data(item){}
};

template <typename T>
class ListRingBuffer
{
private:
    uint32_t m_cap;
    LNode<T>* m_root;
    LNode<T>* m_posr;
    LNode<T>* m_posw;
public:
    ListRingBuffer(int initsize = 10)
        : m_root(NULL),
        m_posr(NULL),
        m_posw(NULL),
        m_cap(initsize)
    {
        if (initsize < 10)
        {
            initsize = 10;
            m_cap = initsize;
        }

        m_root = new LNode<T>;
        //m_root->data = -1;

        LNode<T>* pTail = m_root;

        for (int i = 0; i < initsize; i++)
        {
            LNode<T>* pNode = new LNode<T>;
            //pNode->data = -1;
            pNode->next = m_root;
            m_root = pNode;
        }

        m_posr = m_posw = m_root;
        pTail->next = m_root;
    }

    ~ListRingBuffer()
    {
        while (m_root)
        {
            LNode<T>* pNode = m_root;
            m_root = m_root->next;

            if (pNode)
            {
                delete pNode;
                pNode = NULL;
            }
        }
    }

public:
    int GetCap() { return m_cap; }

    void Push(const T &data)
    {
        /* buffer is full */
        if (m_posw->next == m_posr)
        {
            m_posw->data = data;

            LNode<T>* pNode = new LNode<T>;
            //pNode->data = -1;
            pNode->next = m_posw->next;
            m_posw->next = pNode;

            m_posw = m_posw->next;
            m_cap += 1;
            printf("");
            //printf("cap = %d\\n", m_cap);
        }
        else
        {
            m_posw->data = data;
            m_posw = m_posw->next;
        }
    }

    bool Pull(T& data)
    {
        if (m_posr == m_posw)
        {
            return false;
        }

        data = m_posr->data;
        m_posr = m_posr->next;

        return true;
    }
};
#endif

main.cpp

#include <stdio.h>
#include <Windows.h>

#include "listringbuffer.h"


DWORD WINAPI PushThread(LPVOID lpParam)
{
    ListRingBuffer<int>* pbuff = (ListRingBuffer<int>*)lpParam;
    if (!pbuff)
    {
        return -1;
    }

    int counter = 1;
    while (true)
    {
        pbuff->Push(counter);
        counter++;

        //pbuff->Travel();
        Sleep(1);
    }

    return 0;
}

DWORD WINAPI PullThread(LPVOID lpParam)
{
    ListRingBuffer<int>* pbuff = (ListRingBuffer<int>*)lpParam;
    if (!pbuff)
    {
        return -1;
    }

    int idx = 1;
    while (true)
    {
        int data = 0;
        if (!pbuff->Pull(data))
        {
            continue;
        }
        printf("idx = %d data=%d cap=%d\\n", idx, data, pbuff->GetCap());

        if (idx != data)
        {
            break;
        }

        idx++;
    }

    return 0;
}


int main(int argc, char* argv[])
{
    ListRingBuffer<int> listbuffer;

    HANDLE handles[2] = { NULL };

    DWORD dwPid;
    handles[0] = CreateThread(NULL, 0, PushThread, &listbuffer, 0, &dwPid);
    if (!handles[0])
    {
        printf("create push thread failed, errno:%s\\n", GetLastError());
    }

    handles[1] = CreateThread(NULL, 0, PullThread, &listbuffer, 0, &dwPid);
    if (!handles[1])
    {
        printf("create push thread failed, errno:%s\\n", GetLastError());
    }

    WaitForMultipleObjects(2, handles, TRUE, INFINITE);

    return 0;
}