生产者/消费者问题
请编写一个Producer线程和一个Consumer线程，两个线程共享着一个固定长度的缓冲区和该缓冲区上的一个读写索引index。Producer负责把一些随机数放到缓冲区里，Consumer则负责删除那些随机数。请用C++语言中的信号量。

/////////////////////////////////////////////////////////////////////////////////////////

/* Producer.h （生产者线程类）*/
#include "BoundedBuf.h"
#include "Product.h"

class CProducer
{
private:
    //! 有界缓冲区
    CBoundedBuf *p_buf;
    //! 产品
    CProduct item;
public:
    CProducer();
    CProducer(CBoundedBuf *p);
private:
    //! 初始私有线程
    void init_thread();
    //! 生产产品
    void produce_item(CProduct item);
}

/* Producer.cpp */

#include "Producer.h"    
CProducer::CProducer()
{

}
CProducer::CProducer(CBoundedBuf *p)
{
    p_buf = p;
    init_thread();
};
//! 初始私有线程
void CProducer::init_thread()
{
    while (1)
    {
        //! 生产产品
        produce_item(item);
        //! 把item放入缓存
        p_buf->put(item);
    }
}
void CProducer::produce_item(CProduct item)
{
/*
    产品生产函数省略
*/
}


/////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////

/* Consumer.h （消费者线程类）*/
#include "BoundedBuf.h"
#include "Product.h"

class CConsumer
{
private:
    CBoundedBuf *p_buf;
    CProduct item;
public:
    CConsumer();
    CConsumer(CBoundedBuf *p);
private:    
    //! 初始私有线程
    void init_thread();
    //! 消费产品
    void consume_item(CProduct item);
}

/* Consumer.cpp */
#include "Consumer.h"    
CConsumer::CConsumer(CBoundedBuf *p);
{
    p_buf = p;
    init_thread();
};
void CConsumer::init_thread() //初始私有线程
{
    while (1)
    {
        item = p_buf->get(); //从缓存取item
        consume_item(item);
    }
}
void CConsumer::consume_item(CProduct item)
{
/*
    产品生产函数省略
*/
}

/////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////

/* BoundedBuf.h（有界缓冲区类）*/
#include "Product.h"

#define N 100 /*number of slots in the buffer*/
typedef int semaphore;

typedef struct productNode
{
    CProduct data;
    productNode *next;
}productListHead;

class CBoundedBuf
{
private:
    semaphore mutex;
    semaphore empty;
    semaphore full;
    CProductList* productListHead,productListTail;

public:
    CBoundedBuf();
    ~CBoundedBuf();

public:
    void put(CProduct item);
    CProduct get();

}

/* BoundedBuf.cpp*/    
#include "BoundedBuf.h"
CBoundedBuf::CBoundedBuf()
{    
    semaphore mutex=1;
    semaphore empty=N;
    semaphore full=0;
    
    productListHead = (productNode*) malloc(sizeof(productNode));
//或者productListHead = new CProductNode;
    productListHead->next = NULL;
    productListTail = productListHead;
}
CBoundedBuf::~CBoundedBuf()
{
    CProductList* tp,tp1;
    tp = productListHead;
    while(tp != NULL)
    {
        tp1 = tp->next;
        delete tp;
        tp = tp1;
    }
    productListHead = NULL;
}
void CBoundedBuf::put(CProduct item)
{
down(&empty);
down(&mutex);

CProductNode* tp = new CProduct;
tp->data = item;
tp->next = NULL;
productListTail->next = tp;
productListTail = tp;

up(&mutex);
up(&full);
}

CProduct CBoundedBuf::get()
{
down(&full);
down(&mutex);

CProductNode nt;
CProductNode* tp = productListHead->next;
nt.copy(tp->data);

CProductNode* tp1 = tp->next;
delete tp;
productListHead->next = tp1;

up(&mutex);
up(&empty);
consume_item(item);
return nt;
}





/////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////


    //! 全局变量，传给生产者类和消费者类。
    CBoundedBuf buf;

    CProducer p(&buf);
    CConsumer c(&buf);
    
/////////////////////////////////////////////////////////////////////////////////////////


/////////////////////////////////////////////////////////////////////////////////////////

//CProduct类省略