简要的说明一下这个模式:生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。在同一个进程地址空间内执行的两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。 生产者/消费者模式实现: view plaincopy to clipboardprint? #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, __in SIZE_T dwStackSize, __in LPTHREAD_START_ROUTINE lpStartAddress, __in_opt LPVOID lpParameter, __in DWORD 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( __in HANDLE hSemaphore, __in LONG 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; }