生产者消费者

//生产者－消费者问题

#include

#include

#include

using namespace std;

#define BUF_SIZE 255//字符缓冲区的最大大小，用于输出提示信息

#define MAX_PRODUCER 10 //生产者线程数量

#define MAX_CONSUMER 10 //消费者线程数量

#define MAX_BUF_SIZE 100 //产品缓冲区大小

#define SLEEP_INTERVAL 100.0 //休息时间，该值越大，线程交替速度越慢

typedef struct _Product

{

DWORD _ProductId;

DWORD dwThreadId;

}PRODUCT,*PPRODUCT;

HANDLE hEmpty; //可用的空缓冲区数，初值为MAX_BUF_SIZE

HANDLE hFull; //缓冲区内可用的产品数，初值为0

HANDLE hMutex; //互斥访问缓冲区及下面的两个变量

int in=0; //记录生产者存放产品的缓冲区指针－－生产者使用

int out=0; //记录消费者取出产品的缓冲区指针－－消费者使用PPRODUCT buffer[MAX_BUF_SIZE];//产品缓冲区

//生产者线程

DWORD WINAPI ThreadProduce(LPVOID lpParam)

{

HANDLE hStdout;

TCHAR msgBuf[BUF_SIZE];

size_t cchStringSize;

DWORD dwChars;

hStdout = GetStdHandle(STD_OUTPUT_HANDLE);

if( hStdout == INVALID_HANDLE_VALUE )

return 1;

PDWORD pData;

PPRODUCT p;

pData = (PDWORD)lpParam;

while(1)

{

//生产一件产品

p=(PPRODUCT)HeapAlloc(GetProcessHeap(),

HEAP_ZERO_MEMORY,sizeof(PRODUCT));

p->_ProductId=GetTickCount();//产品编号为

p->dwThreadId=*pData;

WaitForSingleObject(hEmpty,INFINITE);//P操作

WaitForSingleObject(hMutex,INFINITE);//P操作

buffer[in]=p;

StringCchPrintf(msgBuf, BUF_SIZE, TEXT("线程%ld 生产一件产品，产品编号为%d,加入到缓冲区中的第%d个位置\n"),

p->dwThreadId,p->_ProductId,in);

in=(in+1)%MAX_BUF_SIZE;

StringCchLength(msgBuf, BUF_SIZE, &cchStringSize);

WriteConsole(hStdout, msgBuf, (DWORD)cchStringSize, &dwChars, NULL);

ReleaseMutex(hMutex);//V操作

ReleaseSemaphore(hFull,1,NULL); //V操作

Sleep((DWORD)(SLEEP_INTERVAL*rand()/RAND_MAX));//线程暂停一会，也是为了模拟生产过程的不确定性

}

return 0;

}

//消费者线程

DWORD WINAPI ThreadComsumer( LPVOID lpParam )

{

HANDLE hStdout;

TCHAR msgBuf[BUF_SIZE];

size_t cchStringSize;

DWORD dwChars;

hStdout = GetStdHandle(STD_OUTPUT_HANDLE);

if( hStdout == INVALID_HANDLE_VALUE )

return 1;

PDWORD pData;

PPRODUCT p;

pData = (PDWORD)lpParam;

while(1)

{

WaitForSingleObject(hFull,INFINITE);//P操作

WaitForSingleObject(hMutex,INFINITE);//P操作

p=buffer[out];

StringCchPrintf(msgBuf, BUF_SIZE, TEXT("线程%ld 从缓冲区中的第%d个位置取出编号为%d的产品消费,该产品生产者为%ld\n"),

*pData,out,p->_ProductId,p->dwThreadId);

out=(out+1)%MAX_BUF_SIZE;

StringCchLength(msgBuf, BUF_SIZE, &cchStringSize);

WriteConsole(hStdout, msgBuf, (DWORD)cchStringSize, &dwChars, NULL);

ReleaseMutex(hMutex);//V操作

ReleaseSemaphore(hEmpty,1,NULL);//V操作

HeapFree(GetProcessHeap(), 0, p);//释放产品所占空间

Sleep((DWORD)(SLEEP_INTERVAL*p->_ProductId/RAND_MAX));//线程暂停一会，也是为了消费过程的不确性

}

return 0;

}

void main()

{

hEmpty=CreateSemaphore(NULL,MAX_BUF_SIZE,MAX_BUF_SIZE,NULL);

hFull=CreateSemaphore(NULL,0,MAX_BUF_SIZE,NULL);

hMutex=CreateMutex(NULL,FALSE,NULL);

DWORD dwThreadId[MAX_PRODUCER+MAX_CONSUMER]; //存储生产者和消费者线程的线程ID数组

HANDLE hThread[MAX_PRODUCER+MAX_CONSUMER]; //存储生产者和消费者线程的句柄数组

int i;

for( i=0; i

{

hThread[i] = CreateThread(

NULL, // default security attributes

0, // use default stack size

ThreadProduce, // thread function

dwThreadId+i, // 将线程的ID作为参数传递给线程

0, // use default creation flags

dwThreadId+i); // returns the thread identifier

if (hThread[i] == NULL)

{

ExitProcess(i);

}

}

for(i=0;i< MAX_CONSUMER; i++ )

{

hThread[MAX_PRODUCER+i] = CreateThread(

NULL,

0,

ThreadComsumer,

dwThreadId+MAX_PRODUCER+i,

0,

dwThreadId+MAX_PRODUCER+i);

if (hThread[MAX_PRODUCER+i] == NULL)

{

ExitProcess(i);

}

}

// Wait until all threads have terminated.

WaitForMultipleObjects(MAX_PRODUCER+MAX_CONSUMER, hThread, TRUE, INFINITE);

// Close all thread handles upon completion.

for(i=0; i

{

CloseHandle(hThread[i]);

}

}