【数据结构】C++语言无锁环形队列的实现

无锁环形队列

• 1.Ring_Queue在payload前加入一个头，来表示当前节点的状态
• 2.当前节点的状态包括可以读、可以写、正在读、正在写
• 3.当读完成后将节点状态改为可以写，当写完成后将节点状态改为可以读
• 4.Ring_Queue使用时参照生产者消费者模型，生产者生产（写）一个可用节点，消费者获得（读）队列头节点

Github地址： https://github.com/HITFishily/CandCPP

/**************************************************************************************************
* File Name : ring_queue_nolock.h
* Created : 20 / 02 / 10
* Author : GYT
* Description : 无锁环形队列
* 1.Ring_Queue在payload前加入一个头，来表示当前节点的状态
* 2.当前节点的状态包括可以读、可以写、正在读、正在写
* 3.当读完成后将节点状态改为可以写，当写完成后将节点状态改为可以读
* 4.Ring_Queue使用时参照生产者消费者模型，生产者生产（写）一个可用节点，消费者获得（读）队列头节点
**************************************************************************************************/
#include <assert.h>
#include <string.h> 
#include <sys/types.h>        

typedef unsigned char u_char;

#define CAN_WRITE 0x00
#define CAN_READ  0x01
#define READING   0x02
#define WRITING   0x03

typedef struct tag
{
    u_char tag_value;
}TAG;

class Ring_Queue
{
public:
    /**************************************************************************************************
    * Function Name : Ring_Queue
    * Description : 构造函数
    * Date : 20 / 02 / 10
    * Parameter : int nmemb：队列大小 int size：Payload长度
    * Return Code : none
    * Author : GYT
    **************************************************************************************************/
    Ring_Queue(int nmemb, int size):m_inmemb(nmemb), m_isize(size)
        , m_iread_now(0), m_iwrite_now(0)
    {
        if (nmemb <= 0 || size <= 0)
        {
            assert(0);
        }
        m_queue_p = NULL;
        m_queue_p = new u_char[nmemb * (sizeof(TAG)+size)];
        memset(m_queue_p, 0, nmemb * (sizeof(TAG)+size));
    }
    /**************************************************************************************************
    * Function Name : Ring_Queue
    * Description : 析构函数
    * Date : 20 / 02 / 10
    * Parameter : none
    * Return Code : none
    * Author : GYT
    **************************************************************************************************/
    ~Ring_Queue()
    {
        if (m_queue_p) delete[]m_queue_p;

    }
    /**************************************************************************************************
    * Function Name : Read
    * Description : 读取函数
    * Date : 20 / 02 / 10
    * Parameter : none
    * Return Code : 指向payload的指针
    * Author : GYT
    **************************************************************************************************/
    u_char * Read();
    /**************************************************************************************************
    * Function Name : Read_Over
    * Description : 读取之后的操作，将节点状态跟更新为‘可以写’，并将可读节点指向下一个位置
    * Date : 20 / 02 / 10
    * Parameter : none
    * Return Code : none
    * Author : GYT
    **************************************************************************************************/
    void Read_Over();
    /**************************************************************************************************
    * Function Name : Write
    * Description : 写入函数
    * Date : 20 / 02 / 10
    * Parameter : none
    * Return Code : 此时返回一个安全的、可以用来写数据的指针，具体的写入操作由生产者执行
    * Author : GYT
    **************************************************************************************************/
    u_char * Write();
    /**************************************************************************************************
    * Function Name : Write_Over
    * Description : 写入之后的操作，将节点状态跟更新为‘可以读’，并将可写节点指向下一个位置
    * Date : 20 / 02 / 10
    * Parameter : none
    * Return Code : none
    * Author : GYT
    **************************************************************************************************/
    void Write_Over();
private:
    /**************************************************************************************************
    * Function Name : queue_peek_nth
    * Description : 因为整个队列是u_char数组，需要根据字节数偏移至指定位置
    * Date : 20 / 02 / 10
    * Parameter : u_char *queue_p：队列 int pos：需要偏移的位置
    * Return Code : none
    * Author : GYT
    **************************************************************************************************/
    u_char *queue_peek_nth(u_char *queue_p, int pos);
    u_char*      m_queue_p;         //队列指针
    int          m_inmemb;          //队列大小
    int          m_isize;           //队列中存放数据的长度
    volatile int m_iread_now;       //当前可读节点
    volatile int m_iwrite_now;      //当前可写节点
};

#include "ring_queue_nolock.h"

u_char * Ring_Queue::Read()
{
    u_char * g_p = 0;
    TAG * tag_p = 0;
    u_char *user_data = 0;

    g_p = queue_peek_nth(m_queue_p, m_iread_now);
    tag_p = (TAG *)g_p;
    if (tag_p->tag_value == CAN_READ)
    {
        user_data = (u_char *)g_p + sizeof(TAG);
        tag_p->tag_value = READING;
    }
    return user_data;
}

void Ring_Queue::Read_Over()
{
    u_char * g_p = 0;
    TAG * tag_p = 0;

    g_p = queue_peek_nth(m_queue_p, m_iread_now);
    tag_p = (TAG *)g_p;
    if (tag_p->tag_value == READING)
    {
        tag_p->tag_value = CAN_WRITE;
        m_iread_now = (m_iread_now + 1) % m_inmemb;
    }
}

u_char * Ring_Queue::Write()
{
    u_char * g_p = 0;
    TAG * tag_p = 0;
    u_char *user_data = 0;

    g_p = queue_peek_nth(m_queue_p, m_iwrite_now);
    tag_p = (TAG *)g_p;
    if (tag_p->tag_value == CAN_WRITE)
    {
        user_data = (u_char *)g_p + sizeof(TAG);
        tag_p->tag_value = WRITING;
    }
    return user_data;
}

void Ring_Queue::Write_Over()
{
    u_char * g_p = 0;
    TAG * tag_p = 0;

    g_p = queue_peek_nth(m_queue_p, m_iwrite_now);
    tag_p = (TAG *)g_p;
    if (tag_p->tag_value == WRITING)
    {
        tag_p->tag_value = CAN_READ;
        m_iwrite_now = (m_iwrite_now + 1) % m_inmemb;
    }
}

u_char* Ring_Queue::queue_peek_nth(u_char *queue_p, int pos)
{
    u_char *rst = 0;
    if (queue_p && pos < m_inmemb)
    {
        rst = queue_p + pos * (sizeof(TAG)+m_isize);
    }
    return rst;
}