这个模式的详细解释请参考:http://blog.csdn.net/program_think/archive/2009/03/25/4022087.aspx

简要的说明一下这个模式:

消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。

生产者/消费者模式实现:

#include <windows.h>  
#include <iostream>  
 
const unsigned short SIZE_OF_BUFFER = 10; //缓冲区长度  
unsigned short ProductID = 0; //产品号  
unsigned short ConsumeID = 0; //将被消耗的产品号  
unsigned short in = 0; //产品进缓冲区时的缓冲区下标  
unsigned short out = 0; //产品出缓冲区时的缓冲区下标  
 
int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列  
bool g_continue = true; //控制程序结束  
HANDLE g_hMutex; //用于线程间的互斥  
HANDLE g_hFullSemaphore; //当缓冲区满时迫使生产者等待  
HANDLE g_hEmptySemaphore; //当缓冲区空时迫使消费者等待  
 
DWORD WINAPI Producer(LPVOID); //生产者线程  
DWORD WINAPI Consumer(LPVOID); //消费者线程  
 
int main()  
{  
g_hMutex = CreateMutex(NULL,FALSE,NULL);  
//函数功能:建立互斥体，用来同步。如果一个线程获取了互斥体，
//则要获取该互斥体的第二个线程将被挂起，直到第一个线程释放该互斥体。 
//互斥体的好处是可以在进程间共享 
 
//函数原形： 
//HANDLE CreateMutex(  
// LPSECURITY_ATTRIBUTES lpMutexAttributes,  
// BOOL bInitialOwner,  
// LPCTSTR lpName  
// );  
  
//参数说明： 
//lpMutexAttributes： 
//  指向一个SECURITY_ATTRIBUTES结构的指针，这个结构决定互斥体句柄是否被子进程继承。 
//bInitialOwner： 
//  布尔类型，决定互斥体的创建者是否为拥有者 
//TRUE代表主线程拥有互斥对象，但是主线程没有释放该对象，互斥对象谁拥有，谁释放。 
//FLASE代表当前没有线程拥有这个互斥对象 
//lpName： 
//  指向互斥体名字字符串的指针。互斥体可以有名字。 
     
g_hFullSemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL); 
//函数功能:创建信号量 
//在开发软件的过程中，多线程的程序往往需要实现相互通讯，比如几个线程添加一个消息到队列里， 
//而另一个线程在睡眠时，就需要唤醒那个线程来处理事情。在这其中，就需要使用到信号量来进行同步。 
//CreateSemaphore是创建信号量，ReleaseSemaphore是增加信号量。 
 
//函数原形： 
//HANDLE 
// WINAPI 
// CreateSemaphoreW( 
    // __in_opt LPSECURITY_ATTRIBUTES lpSemaphoreAttributes, 
// __in LONG lInitialCount, 
    // __in LONG lMaximumCount, 
    // __in_opt LPCWSTR lpName 
// ); 
 
//参数说明： 
//lpSemaphoreAttributes是信号量的安全属性。 
//lInitialCount是初始化的信号量。 
//lMaximumCount是允许信号量增加到最大值。 
//lpName是信号量的名称。 
 
  
g_hEmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);  
 
 
const unsigned short PRODUCERS_COUNT = 3; //生产者的个数  
const unsigned short CONSUMERS_COUNT = 1; //消费者的个数  
const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;
//总的线程数（不是进程数）  
 
HANDLE hThreads[PRODUCERS_COUNT]; //各线程的handle  
DWORD producerID[CONSUMERS_COUNT]; //生产者线程的标识符  
DWORD consumerID[THREADS_COUNT]; //消费者线程的标识符  
 
//创建PRODUCERS_COUNT个线程 
for (int i=0;i<PRODUCERS_COUNT;++i){  
hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]);  
 
//函数功能:创建线程 
/*HANDLE 
WINAPI 
CreateThread( 
__in_opt LPSECURITY_ATTRIBUTES lpThreadAttributes, 
__inSIZE_T dwStackSize, 
__inLPTHREAD_START_ROUTINE lpStartAddress, 
__in_opt LPVOID lpParameter, 
__inDWORD dwCreationFlags, 
__out_opt LPDWORD lpThreadId 
); 
 
lpThreadAttributes是线程的属性。 
dwStackSize是线程的栈大小。 
lpStartAddress是线程函数的开始地址。 
lpParameter是传送给线程函数的参数。 
dwCreationFlags是创建线程标志，比如挂起线程。 
lpThreadId是标识这个线程的ID。*/ 
//注意：lpThreadId是输出参数，也就是说这个线程的ID被保存在lpThreadId中。 
//lpStartAddress是把这个线程和这个函数关联起来，
//也就是这个线程一旦创建就执行这个函数。 
 
 
 
if (hThreads[i]==NULL) return -1;  
}  
  
//创建CONSUMERS_COUNT个线程 
for ( int i=0;i<CONSUMERS_COUNT;++i){  
hThreads[PRODUCERS_COUNT+i]=
 CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]);  
if (hThreads[i]==NULL) return -1;  
}  
 
while(g_continue){  
if(getchar()){ //按回车后终止程序运行 
g_continue = false;  
}  
}  
 
return 0;  
}  
 
 //生产一个产品,并输出提示信息 
void Produce()  
{  
std::cerr << "Producing " << ++ProductID << " ... ";  
std::cerr << "Succeed" << std::endl;  
}  
 
//增加产品到缓冲区 
void Append()  
{  
std::cerr << "Appending a product ... ";  
g_buffer[in] = ProductID;  
in = (in+1)%SIZE_OF_BUFFER; //这句很经典，构造循环队列的关键 
std::cerr << "Succeed" << std::endl;  
 
//输出缓冲区当前的状态  
for (int i=0;i<SIZE_OF_BUFFER;++i){  
std::cout << i <<": " << g_buffer[i];  
if (i==in) std::cout << " <-- 生产";  
if (i==out) std::cout << " <-- 消费";  
std::cout << std::endl;  
}  
}  
 
 //从缓冲区移除产品 
void Take()  
{  
std::cerr << "Taking a product ... ";  
ConsumeID = g_buffer[out];  
out = (out+1)%SIZE_OF_BUFFER;  
std::cerr << "Succeed" << std::endl;  
 
//输出缓冲区当前的状态  
for (int i=0;i<SIZE_OF_BUFFER;++i){  
std::cout << i <<": " << g_buffer[i];  
if (i==in) std::cout << " <-- 生产";  
if (i==out) std::cout << " <-- 消费";  
std::cout << std::endl;  
}  
}  
 
//消费一个产品 
void Consume()  
{  
std::cerr << "Consuming " << ConsumeID << " ... ";  
std::cerr << "Succeed" << std::endl;  
}  
 
//生产者 
DWORD WINAPI Producer(LPVOID lpPara)  
{  
while(g_continue){  
WaitForSingleObject(g_hFullSemaphore,INFINITE);  
//用来检测hHandle事件的信号状态 
/*WINBASEAPI 
DWORD 
WINAPI 
WaitForSingleObject( 
__in HANDLE hHandle, 
__in DWORD dwMilliseconds 
); 
hHandle是等待对象的句柄。 
dwMilliseconds是等待的时间条件，INFINITE表示永远等待下去。*/ 
 
WaitForSingleObject(g_hMutex,INFINITE);  
Produce();  
Append();  
Sleep(1500);  
     
ReleaseMutex(g_hMutex);  
//Releases ownership of the specified mutex object. 
//Parameters: A handle to the mutex object 
 
 
ReleaseSemaphore(g_hEmptySemaphore,1,NULL); 
/*WINAPI 
ReleaseSemaphore( 
__inHANDLE hSemaphore, 
__inLONG lReleaseCount, 
__out_opt LPLONG lpPreviousCount 
); 
 
hSemaphore是要增加的信号量句柄。 
lReleaseCount是增加的计数。 
lpPreviousCount是增加前的数值返回。*/ 
 
  
}  
return 0;  
}  
 
//消费者 
DWORD WINAPI Consumer(LPVOID lpPara)  
{  
while(g_continue){  
WaitForSingleObject(g_hEmptySemaphore,INFINITE);  
WaitForSingleObject(g_hMutex,INFINITE);  
Take();  
Consume();  
Sleep(1500);  
ReleaseMutex(g_hMutex);  
ReleaseSemaphore(g_hFullSemaphore,1,NULL);  
}  
return 0;  
}