无锁环形队列

#include "stdafx.h"
#include <process.h>
#include <stdio.h>
#include <Windows.h>
#include <stdlib.h>
#include <assert.h>

#define MAX_VIDEO_BUFF 1024

struct Header
{
    WORD wSize;
    char data[0];
};

#define TEST_MSG_MAX_SIZE 128
#define MAX_VIDEO_ELEMENT (TEST_MSG_MAX_SIZE + sizeof(Header))

class VideoQueue
{
public:
    VideoQueue() : r(0), w(0), buf(0), buf_extend(0) {}

//////////////////////////////////////////////////////////////////////
//////////////////// WRITE ///////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

    bool Write(const char* p, int len)
    {
        if (GetSpaceSize() < len)
            return false;

        int toendlen = MAX_VIDEO_BUFF - w;
        if (toendlen >= len)
            memcpy(&buf[w], p, len);
        else 
        {
            memcpy(&buf[w], p, toendlen);
            memcpy(&buf[0], p + toendlen, len - toendlen);
        }

        w = (w + len) % MAX_VIDEO_BUFF;
        return true;
    }
    bool IsFull() { 
        return ((w + 1) % MAX_VIDEO_BUFF == r); 
    }
    int GetSpaceSize()    
    {
        int rt = r + MAX_VIDEO_BUFF - w - 1;
        if (rt >= MAX_VIDEO_BUFF)
            rt -= MAX_VIDEO_BUFF;
        return rt;
    }

//////////////////////////////////////////////////////////////////////
//////////////////// READ ////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////

    const char* GetDataPtr(int len)
    {
        if (GetDataLength() < len)
            return 0;

        if (len > MAX_VIDEO_ELEMENT)
            return 0;

        int toendlen = MAX_VIDEO_BUFF - r;
        if (toendlen >= len)
            return &buf[r];
        else
        {
            memcpy(buf_extend, &buf[r], toendlen);
            memcpy(((char*)buf_extend) + toendlen, &buf[0], len - toendlen);
            return (const char*)buf_extend;
        }
    }
    bool IsEmpty() { 
        return (w == r); 
    }
    bool Skip(int len)
    { 
        assert(GetDataLength() >= len); 
        r = (r + len) % MAX_VIDEO_BUFF; 
        return true; 
    }
    int GetDataLength()
    {
        int rt = w + MAX_VIDEO_BUFF - r;
        if (rt >= MAX_VIDEO_BUFF)
            rt -= MAX_VIDEO_BUFF;
        return rt;
    }


    //////
    bool CreateBuff() 
    {
        if (buf == 0)
            buf = (char*)malloc(MAX_VIDEO_BUFF);

        if (buf_extend == 0)
            buf_extend = (char*)malloc(MAX_VIDEO_ELEMENT);

        return (buf != 0);
    }
    
private:
    char* buf;//数据实际上只能写入MAX_BUFF-1    
    int r;
    int w;
    char* buf_extend;
};


VideoQueue* q = 0;

CRITICAL_SECTION cs;

#define TEST_MSG_COUNT 100000
void ThreadA(void*)
{
    // 创建消息，不断向队列里填充
    char s_Buff[TEST_MSG_MAX_SIZE + sizeof(Header)];
    Header *pHeader = (Header *)s_Buff;
    int iLeftCount = 0;
    int iPos = 0;
    int iSendSize = 0;
    int iPackIndex = 0;
    int iTotalSize = 0;

    while (1)
    {
        //EnterCriticalSection(&cs);

        if (q->IsFull())
        {
            //LeaveCriticalSection(&cs);
            //Sleep(0);
            continue;
        }

        if (iLeftCount == 0)
        {
            if (iPackIndex++ >= TEST_MSG_COUNT)
            {
                //LeaveCriticalSection(&cs);
                break;
            }

            // Create a Msg;
            pHeader->wSize = rand() % (TEST_MSG_MAX_SIZE - 32) + 32;
            for (WORD i = 0; i < pHeader->wSize; ++i)
                pHeader->data[i] = char(pHeader->wSize + i);
            iTotalSize += pHeader->wSize;
            iLeftCount = pHeader->wSize + sizeof(Header);
            iPos = 0;
        }

        int iSpace = q->GetSpaceSize();
        if (iLeftCount > TEST_MSG_MAX_SIZE / 4)
            iSendSize = rand() % iLeftCount;
        else
            iSendSize = iLeftCount;

        if (iSpace < iSendSize)
        {
            assert(q->Write(s_Buff + iPos, iSpace));
            iLeftCount -= iSpace;
            iPos += iSpace;
        }
        else
        {
            assert(q->Write(s_Buff + iPos, iSendSize));
            iLeftCount -= iSendSize;
            iPos += iSendSize;
        }

        //LeaveCriticalSection(&cs);
        //Sleep(0);
    }
    printf("Send %d Msg, Size:%d!
", TEST_MSG_COUNT, iTotalSize);

    // __EndThreadEx
}

void ThreadB(void*)
{
    // 不断从队列里读消息
    Header *pHeader = NULL;

    int iMsgCount = 0;
    int iTotalSize = 0;
    int iErrorPack = 0;

    while (1)
    {
        //EnterCriticalSection(&cs);
        if (q->IsEmpty())
        {
            //LeaveCriticalSection(&cs);
            //Sleep(0);
            continue;
        }

        pHeader = (Header *)q->GetDataPtr(sizeof(Header));
        if (pHeader)
        {
            pHeader = (Header *)q->GetDataPtr(sizeof(Header) + pHeader->wSize);
            if (pHeader)
            {
                for (WORD i = 0; i < pHeader->wSize; ++i)
                    if (pHeader->data[i] != char(pHeader->wSize + i))
                    {
                        iErrorPack++;
                        break;
                    }

                iMsgCount ++;
                iTotalSize += pHeader->wSize;
                q->Skip(sizeof(Header) + pHeader->wSize);

                if (iMsgCount >= TEST_MSG_COUNT)
                {
                    //LeaveCriticalSection(&cs);
                    break;
                }
            }
        }
        //LeaveCriticalSection(&cs);
        //Sleep(0);
    }
    printf("Recv %d Msg, Size:%d, ErrorPack:%d!
", TEST_MSG_COUNT, iTotalSize,iErrorPack);

    // __EndThreadEx
}

int _tmain(int argc, _TCHAR* argv[])
{
    srand(1);
    q = new VideoQueue;
    if (!q->CreateBuff())
    {
        printf("createbuff fail
");
        getchar();
        return 0;
    }
    InitializeCriticalSection(&cs);

    HANDLE hWrite = (HANDLE)_beginthread(ThreadA, 0, 0);
    HANDLE hRead = (HANDLE)_beginthread(ThreadB, 0, 0);

    WaitForSingleObject(hWrite, INFINITE);
    WaitForSingleObject(hRead, INFINITE);

     getchar();
 
     return 0;
}