多线程_生产者消费者

1. 这个就不多说了，直接上代码：
2. 
   
3. 1. #include<windows.h>   
   2. #include<iostream>   
   3. using namespace std;  
   4.   
   5. const unsigned short SIZE_OF_BUFFER = 10;   //缓冲区长度   
   6. unsigned short ProductID = 0;         //产品号   
   7. unsigned short ConsumeID = 0;         //将被消耗的产品号   
   8. unsigned short in = 0;             //产品进缓冲区时的缓冲区下标   
   9. unsigned short out = 0;             //产品出缓冲区时的缓冲区下标   
   10.   
   11. int g_buffer[SIZE_OF_BUFFER];         //缓冲区是个循环队列   
   12.          
   13. CRITICAL_SECTION g_cs;             //用于线程间的互斥   
   14. HANDLE g_hFullSemaphore;           //当缓冲区满时迫使生产者等待   
   15. HANDLE g_hEmptySemaphore;           //当缓冲区空时迫使消费者等待   
   16.   
   17. DWORD WINAPI Producer(LPVOID);         //生产者线程   
   18. DWORD WINAPI Consumer(LPVOID);         //消费者线程   
   19.   
   20. int main()   
   21. {   
   22.     //创建各个互斥信号   
   23.     InitializeCriticalSection( &g_cs);   
   24.     g_hFullSemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL);   
   25.     g_hEmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL);   
   26.       
   27.     //调整下面的数值，可以发现，当生产者个数多于消费者个数时，   
   28.     //生产速度快，生产者经常等待消费者；反之，消费者经常等待     
   29.     const unsigned short PRODUCERS_COUNT = 3;     //生产者的个数   
   30.     const unsigned short CONSUMERS_COUNT = 1;     //消费者的个数   
   31.       
   32.     //总的线程数   
   33.     const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT;   
   34.     //各线程的handle   
   35.     HANDLE hThreads[PRODUCERS_COUNT];    
   36.     //创建生产者线程   
   37.     for(int i = 0; i < PRODUCERS_COUNT; ++i)  
   38.     {   
   39.         hThreads[i] = CreateThread(NULL,0,Producer,NULL,0,NULL);   
   40.         if(hThreads[i] == NULL)  
   41.             return   -1;   
   42.     }   
   43.     //创建消费者线程   
   44.     for( i=0; i < CONSUMERS_COUNT; ++i)  
   45.     {   
   46.         hThreads[PRODUCERS_COUNT+i] = CreateThread(NULL,0,Consumer,NULL,0,NULL);   
   47.         if (hThreads[i]==NULL)  
   48.             return   -1;   
   49.     }   
   50.       
   51.     Sleep(100000);  
   52.     DeleteCriticalSection(&g_cs);  
   53.     return   0;   
   54. }   
   55.   
   56. //生产一个产品。简单模拟了一下，仅输出新产品的ID号   
   57. void   Produce()   
   58. {   
   59.      cerr << "Producing  " << ++ProductID <<  "   ...   ";   
   60.      cerr << "Succeed " << endl;   
   61. }   
   62.   
   63. //把新生产的产品放入缓冲区   
   64. void   Append()   
   65. {   
   66.      cerr << "Appending   a   product   ...   ";   
   67.     g_buffer[in]   =   ProductID;   
   68.     in   =   (in+1) % SIZE_OF_BUFFER;   
   69.      cerr << "Succeed " << endl;   
   70.       
   71.     //输出缓冲区当前的状态   
   72.     for (int i=0; i < SIZE_OF_BUFFER; ++i){   
   73.         cout << i << ":   " << g_buffer[i];   
   74.         if(i==in) cout << "   <--   生产 ";   
   75.         if(i==out) cout << "   <--   消费 ";   
   76.          cout << endl;   
   77.     }   
   78. }   
   79.   
   80. //从缓冲区中取出一个产品   
   81. void   Take()   
   82. {   
   83.     cerr << "Taking   a   product   ...   ";   
   84.     ConsumeID   =   g_buffer[out];   
   85.     out = (out+1)%SIZE_OF_BUFFER;   
   86.     cerr << "Succeed " << endl;   
   87.       
   88.     //输出缓冲区当前的状态   
   89.     for   (int   i=0;i <SIZE_OF_BUFFER;++i){   
   90.          cout << i << ":   " << g_buffer[i];   
   91.         if  (i==in)cout << "   <--   生产 ";   
   92.         if  (i==out)cout << "   <--   消费 ";   
   93.          cout << endl;   
   94.     }   
   95. }   
   96.   
   97. //消耗一个产品   
   98. void   Consume()   
   99. {   
   100.      cerr  <<   "Consuming   " <<ConsumeID<<"   ...   " <<   "Succeed " <<  endl;   
   101. }   
   102.   
   103. //生产者   
   104. DWORD WINAPI Producer(LPVOID lpPara)   
   105. {   
   106.     while(1){   
   107.         WaitForSingleObject(g_hFullSemaphore,INFINITE);   
   108.         EnterCriticalSection(&g_cs);  
   109.         Produce();   
   110.         Append();   
   111.         Sleep(1500);   
   112.         LeaveCriticalSection(&g_cs);  
   113.         ReleaseSemaphore(g_hEmptySemaphore,1,NULL);   
   114.     }   
   115.     return   0;   
   116. }   
   117.   
   118. //消费者   
   119. DWORD WINAPI Consumer(LPVOID lpPara)   
   120. {   
   121.     while(1){   
   122.         WaitForSingleObject(g_hEmptySemaphore,INFINITE);   
   123.         EnterCriticalSection(&g_cs);  
   124.         Take();   
   125.         Consume();   
   126.         Sleep(1500);   
   127.         LeaveCriticalSection(&g_cs);  
   128.         ReleaseSemaphore(g_hFullSemaphore,1,NULL);   
   129.     }   
   130.     return   0;   
   131. }