循环队列，支持多线程

static const char S_FILL[] = "cycle_queue_fill_";
static const char S_EMPTY[] = "cycle_queue_empty_";

template<class T>
class CycleQueueT
{
private:
    CycleQueueT(const CycleQueueT&);
    CycleQueueT& operator= (const CycleQueueT&);

public:
    CycleQueueT(T *buffer, unsigned int count, const std::string &strConnectName)
        : count_(count)
        , front_(0)
        , rear_(0)
        , writePtr_(buffer)
        , readPtr_(buffer)
        , hFill_(NULL)
        , hEmpty_(NULL)
    {
        hFill_ = CreateSemaphoreA(NULL, count_, count_, (strConnectName+S_FILL).c_str());
        hEmpty_ = CreateSemaphoreA(NULL, 0, count_, (strConnectName+S_EMPTY).c_str());
    }

    void set(T *buffer, bool blWrite)
    {
        assert(NULL != buffer);

        if (blWrite){
            writePtr_ = buffer;
        }
        else{
            readPtr_ = buffer;
        }
    }

    void put(const T *elem)
    {
        WaitForSingleObject(hFill_, INFINITE);
        memcpy(writePtr_+rear_, elem, sizeof(T));
        rear_ = (rear_ + 1) % count_;
        ReleaseSemaphore(hEmpty_, 1, NULL);

    }

    void get(T *elem)
    {
        WaitForSingleObject(hEmpty_, INFINITE);
        memcpy(elem, readPtr_+front_, sizeof(T));
        front_ = (front_ + 1) % count_;
        ReleaseSemaphore(hFill_, 1, NULL);
    }

    unsigned int size() const
    {
        return (rear_ - front_ + count_) % count_;
    }

private:
    unsigned int count_;
    unsigned int front_;
    unsigned int rear_;
    T *writePtr_;
    T *readPtr_;
    void *hFill_;
    void *hEmpty_;
};