[notice: All Rights Reserved. Please reprint. Do not use for commercial purposes. Contact email: feixiaoxing@163.com]


Producer consumer is an interesting algorithm. Its existence is mainly for two purposes, the first is to meet the continuous creation of resources by producers; the second is to meet the continuous demand of resources by consumers. Of course, because of the limited space, resources can neither be stored nor acquired indefinitely.

Producer's algorithm,

1. WaitForSingleObject(hEmpty, INFINITE);  
2. WaitForSingleObject(hMutex, INIFINITE);  
3. /* produce new resources */  
4. ReleaseMutex(hMutex);  
5. ReleaseSemaphore(hFull, 1, NULL);  

Consumer's algorithm,

1. WaitForSingleObject(hFull, INFINITE);  
2. WaitForSingleObject(hMutex, INIFINITE);  
3. /* consume old resources */  
4. ReleaseMutex(hMutex);  
5. ReleaseSemaphore(hEmpty, 1, NULL);  

Then, some friends may say, what is the function of such a producer consumer algorithm. Let's see how it works in multithreaded communication? First, we define a data structure,

1. typedef struct _MESSAGE_QUEUE  
2. {  
3.     int threadId;  
4.     int msgType[MAX_NUMBER];  
5.     int count;  
6.     HANDLE hFull;  
7.     HANDLE hEmpty;  
8.     HANDLE hMutex;  
9. }MESSAGE_QUEUE;  

So, at this time, if we need to send messages to a thread, how to send them is very simple. We can think of it as the operation of a producer.

1. void send_mseesge(int threadId, MESSAGE_QUEUE* pQueue, int msg)  
2. {  
3.     assert(NULL != pQueue);  
4.       
5.     if(threadId != pQueue->threadId)  
6.         return;  
7.   
8.     WaitForSingleObject(pQueue->hEmpty, INFINITE);  
9.     WaitForSingleObject(pQueue->hMutex, INFINITE);  
10.     pQueue->msgType[pQueue->count ++] = msg;  
11.     ReleaseMutex(pQueue->hMutex);  
12.     ReleaseSemaphore(pQueue->hFull, 1, NULL);      
13. }  

Now that we talked about sending messages, the thread itself has to process these messages.

1. void get_message(MESSAGE_QUEUE* pQueue, int* msg)  
2. {  
3.     assert(NULL != pQueue && NULL != msg);  
4.   
5.     WaitForSingleObject(pQueue->hFull, INFINITE);  
6.     WaitForSingleObject(pQueue->hMutex, INFINITE);  
7.     *msg = pQueue->msgType[pQueue->count --];  
8.     ReleaseMutex(pQueue->hMutex);  
9.     ReleaseSemaphore(pQueue->hEmpty, 1, NULL);     
10. }  

Summary:
(1) producer consumer can only use sempoint as lock
(2) when writing code, you need to judge the order of hFull and hEmpty
(3) it's very important to master the basic algorithm of producer consumer, but more importantly, it's own practice