生产者消费者算法c++版

//*                 实验一   生产者消费者问题                                *//

//******************************************************************************//

#include 

#include 

#include 

const unsigned short SIZE_OF_BUFFER = 10; //缓冲队列长度

unsigned short ProductID = 0;    //产品号

unsigned short ConsumeID = 0;    //将被消耗的产品号

unsigned short in = 0;      //相当于缓冲单元指针，生产者进程每次将产品放入该指针指示的缓冲单元，并将指针后移一个缓冲单元

unsigned short out = 0;      //相当于缓冲单元指针，消费者进程每次从该指针指示的缓冲单元取出产品，并将指针后移一个缓冲单元

typedef struct BufferType{

    int productID;

    int state;    //0表示缓冲单元空，表示缓冲单元满（有产品）

}Buffer;

Buffer g_buffer[SIZE_OF_BUFFER];    //缓冲队列（作为循环队列使用）

bool g_continue = true;      //控制程序结束

HANDLE g_hMutex;       //线程间互斥的信号量

HANDLE g_hEmptySemaphore;     //线程间同步的信号量

HANDLE g_hFullSemaphore;     //线程间同步的信号量

DWORD WINAPI Producer(LPVOID);    //生产者线程

DWORD WINAPI Consumer(LPVOID);    //消费者线程

int main()

{

    //创建互斥的信号量和同步的信号量

    g_hMutex = CreateMutex(NULL,FALSE,NULL);

    g_hEmptySemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER,SIZE_OF_BUFFER,NULL);

    g_hFullSemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER,NULL);

    //调整下面的数值，可以发现，当生产者个数多于消费者个数时，生产速度快，生产者经常等待消费者；反之，消费者经常等待

    const unsigned short PRODUCERS_COUNT = 3;  //要创建的生产者线程的个数

    const unsigned short CONSUMERS_COUNT = 1;  //要创建的消费者线程的个数

    //总的线程数

    const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;

    HANDLE hProducerThread[PRODUCERS_COUNT];//生产者线程的handle

    HANDLE hConsumerThread[CONSUMERS_COUNT];//消费者线程的handle

    DWORD producerID[PRODUCERS_COUNT]; //生产者线程ID

    DWORD consumerID[CONSUMERS_COUNT]; //消费者线程ID

    int i;

    //创建生产者线程

    for (i=0;i        hProducerThread[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);

        if (hProducerThread[i]==NULL) return -1;

    }

    //创建消费者线程

    for (i=0;i        hConsumerThread[i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);

        if (hConsumerThread[i]==NULL) return -1;

    }

    if(getchar()){ //按回车后终止程序运行

        g_continue = false;

    }

    return 0;

}

//生产者把新生产的产品放入缓冲区

void AddToBuffer()

{

    ProductID++; //生产者生产出产品号

    g_buffer[in].productID = ProductID;//将产品放入缓冲单元

    g_buffer[in].state=1;//置“满”标志

    //输出缓冲队列当前的状态

cout<<"\\n生产者将产品"< cout<<"缓冲单元编号"<<"   "<<"产品编号"<<"   "<<"缓冲单元状态"<    for (int i=0;i     cout<<"    "<    }

    in = (in+1)%SIZE_OF_BUFFER;//更新指针，使其指向生产者下一次需要操作的缓冲单元

}

//从缓冲区中取出一个产品

void TakeFromBuffer()

{

    ConsumeID = g_buffer[out].productID;//从缓冲队列中取出一个产品

    g_buffer[out].productID=0;//删除该缓冲单元内容

    g_buffer[out].state=0;//置“空”标识

    //输出缓冲队列当前的状态

cout<<"\\n消费者从缓冲单元"< cout<<"缓冲单元编号"<<"   "<<"产品编号"<<"   "<<"缓冲单元状态"<    for (int i=0;i     cout<<"    "<    }

    out = (out+1)%SIZE_OF_BUFFER;//更新指针，使其指向消费者下一次需要操作的缓冲单元

}

//生产者

DWORD  WINAPI Producer(LPVOID lpPara)

{

    while(g_continue){

        WaitForSingleObject(g_hEmptySemaphore,INFINITE);

        WaitForSingleObject(g_hMutex,INFINITE);     

        AddToBuffer();

        Sleep(200);

        ReleaseMutex(g_hMutex);

        ReleaseSemaphore(g_hFullSemaphore,1,NULL);

    }

    return 0;

}

//消费者

DWORD  WINAPI Consumer(LPVOID lpPara)

{

    while(g_continue){

        WaitForSingleObject(g_hFullSemaphore,INFINITE);

        WaitForSingleObject(g_hMutex,INFINITE);

        TakeFromBuffer();

        Sleep(200);

        ReleaseMutex(g_hMutex);

        ReleaseSemaphore(g_hEmptySemaphore,1,NULL);

    }

     return 0;

}