Windows线程（生产者与消费者问题）

Windows线程（生产者与消费者问题） 转载 佟强 2008.10.10

     生产者-消费者问题是一个经典的进程同步问题，该问题最早由Dijkstra提出，用以演示他提出的信号量机制。在同一个进程地址空间内执行的两个线程。生产者线程生产物品，然后将物品放置在一个空缓冲区中供消费者线程消费。消费者线程从缓冲区中获得物品，然后释放缓冲区。当生产者线程生产物品时，如果没有空缓冲区可用，那么生产者线程必须等待消费者线程释放出一个空缓冲区。当消费者线程消费物品时，如果没有满的缓冲区，那么消费者线程将被阻塞，直到新的物品被生产出来。

1. #include  
2. #include  
4. const unsigned short SIZE_OF_BUFFER = 10; //缓冲区长度 
5. unsigned short ProductID = 0; //产品号 
6. unsigned short ConsumeID = 0; //将被消耗的产品号 
7. unsigned short in = 0; //产品进缓冲区时的缓冲区下标 
8. unsigned short out = 0; //产品出缓冲区时的缓冲区下标 
10. int g_buffer[SIZE_OF_BUFFER]; //缓冲区是个循环队列 
11. bool g_continue = true; //控制程序结束 
12. HANDLE g_hMutex; //用于线程间的互斥 
13. HANDLE g_hFullSemaphore; //当缓冲区满时迫使生产者等待 
14. HANDLE g_hEmptySemaphore; //当缓冲区空时迫使消费者等待 
16. DWORD WINAPI Producer(LPVOID); //生产者线程 
17. DWORD WINAPI Consumer(LPVOID); //消费者线程 
19. int main() 
20. { 
21.  //创建各个互斥信号 
22.  g_hMutex = CreateMutex(NULL,FALSE,NULL); 
23.  g_hFullSemaphore = CreateSemaphore(NULL,SIZE_OF_BUFFER-1,SIZE_OF_BUFFER-1,NULL); 
24.  g_hEmptySemaphore = CreateSemaphore(NULL,0,SIZE_OF_BUFFER-1,NULL); 
26.  //调整下面的数值，可以发现，当生产者个数多于消费者个数时， 
27.  //生产速度快，生产者经常等待消费者；反之，消费者经常等待 
28.  const unsigned short PRODUCERS_COUNT = 3; //生产者的个数 
29.  const unsigned short CONSUMERS_COUNT = 1; //消费者的个数 
31.  //总的线程数 
32.  const unsigned short THREADS_COUNT = PRODUCERS_COUNT+CONSUMERS_COUNT; 
34.  HANDLE hThreads[PRODUCERS_COUNT]; //各线程的handle 
35.  DWORD producerID[CONSUMERS_COUNT]; //生产者线程的标识符 
36.  DWORD consumerID[THREADS_COUNT]; //消费者线程的标识符 
38.  //创建生产者线程 
39.  for (int i=0;i
40.   hThreads[i]=CreateThread(NULL,0,Producer,NULL,0,&producerID[i]); 
41.   if (hThreads[i]==NULL) return -1; 
42.  } 
43.  //创建消费者线程 
44.  for (int i=0;i
45.   hThreads[PRODUCERS_COUNT+i]=CreateThread(NULL,0,Consumer,NULL,0,&consumerID[i]); 
46.   if (hThreads[i]==NULL) return -1; 
47.  } 
49.  while(g_continue){ 
50.   if(getchar()){ //按回车后终止程序运行 
51.    g_continue = false; 
52.   } 
53.  } 
55.  return 0; 
56. } 
58. //生产一个产品。简单模拟了一下，仅输出新产品的ID号 
59. void Produce() 
60. { 
61.  std::cerr << "Producing " << ++ProductID << " ... "; 
62.  std::cerr << "Succeed" << std::endl; 
63. } 
65. //把新生产的产品放入缓冲区 
66. void Append() 
67. { 
68.  std::cerr << "Appending a product ... "; 
69.  g_buffer[in] = ProductID; 
70.  in = (in+1)%SIZE_OF_BUFFER; 
71.  std::cerr << "Succeed" << std::endl; 
73.  //输出缓冲区当前的状态 
74.  for (int i=0;i
75.   std::cout << i <<": " << g_buffer[i]; 
76.   if (i==in) std::cout << " <-- 生产"; 
77.   if (i==out) std::cout << " <-- 消费"; 
78.   std::cout << std::endl; 
79.  } 
80. } 
82. //从缓冲区中取出一个产品 
83. void Take() 
84. { 
85.  std::cerr << "Taking a product ... "; 
86.  ConsumeID = g_buffer[out]; 
87.  out = (out+1)%SIZE_OF_BUFFER; 
88.  std::cerr << "Succeed" << std::endl; 
90.  //输出缓冲区当前的状态 
91.  for (int i=0;i
92.   std::cout << i <<": " << g_buffer[i]; 
93.   if (i==in) std::cout << " <-- 生产"; 
94.   if (i==out) std::cout << " <-- 消费"; 
95.   std::cout << std::endl; 
96.  } 
97. } 
99. //消耗一个产品 
100. void Consume() 
101. { 
102.  std::cerr << "Consuming " << ConsumeID << " ... "; 
103.  std::cerr << "Succeed" << std::endl; 
104. } 
106. //生产者 
107. DWORD WINAPI Producer(LPVOID lpPara) 
108. { 
109.  while(g_continue){ 
110.   WaitForSingleObject(g_hFullSemaphore,INFINITE); 
111.   WaitForSingleObject(g_hMutex,INFINITE); 
112.   Produce(); 
113.   Append(); 
114.   Sleep(1500); 
115.   ReleaseMutex(g_hMutex); 
116.   ReleaseSemaphore(g_hEmptySemaphore,1,NULL); 
117.  } 
118.  return 0; 
119. } 
121. //消费者 
122. DWORD WINAPI Consumer(LPVOID lpPara) 
123. { 
124.  while(g_continue){ 
125.   WaitForSingleObject(g_hEmptySemaphore,INFINITE); 
126.   WaitForSingleObject(g_hMutex,INFINITE); 
127.   Take(); 
128.   Consume(); 
129.   Sleep(1500); 
130.   ReleaseMutex(g_hMutex); 
131.   ReleaseSemaphore(g_hFullSemaphore,1,NULL); 
132.  } 
133.  return 0; 
134. }