Windows Thread (producer and consumer issues)

Windows Thread (producer and consumer problems) reprinted by qiqiang 2008.10.10

The producer-consumer problem is a classic process synchronization problem first proposed by Dijkstra to demonstrate the semaphore mechanism proposed by him. Two threads executed in the same process address space. The producer thread produces the item and places the item in an empty buffer for consumption by the consumer thread. The consumer thread obtains the item from the buffer and then releases the buffer. When the producer thread produces an item, if no empty buffer zone is available, the producer thread must wait for the consumer thread to release an empty buffer zone. When the consumer thread consumes an item, if the buffer is not full, the consumer thread will be blocked until the new item is produced.

1. # Include <windows. h>
2. # Include <iostream>
4. Const unsigned short size_of_buffer = 10; // buffer Length
5. Unsigned short productid = 0; // Product NO.
6. Unsigned short consumeid = 0; // product number to be consumed
7. Unsigned short in = 0; // buffer subscript when the product enters the Buffer Zone
8. Unsigned short out = 0; // buffer subscript when the product outputs the Buffer Zone
10. Int g_buffer [size_of_buffer]; // the buffer is a cyclic queue.
11. Bool g_continue = true; // The control program ends.
12. Handle g_hmutex; // used for mutual exclusion between threads
13. Handle g_hfullsemaphore; // forces the producer to wait when the buffer is full.
14. Handle g_hemptysemaphore; // force the consumer to wait when the buffer zone is empty
16. DWORD winapi producer (lpvoid); // producer thread
17. DWORD winapi consumer (lpvoid); // consumer thread
19. Int main ()
20. {
21. // Create mutually exclusive Signals
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. // Adjust the values below to find that when the number of producers is greater than the number of consumers,
27. // The production speed is fast, and the producer often waits for the consumer. On the contrary, the consumer often waits
28. Const unsigned short producers_count = 3; // number of producers
29. Const unsigned short consumers_count = 1; // number of consumers
31. // Total number of threads
32. Const unsigned short threads_count = producers_count + consumers_count;
34. Handle hthreads [producers_count]; // handle of each thread
35. DWORD producerid [consumers_count]; // producer thread identifier
36. DWORD consumerid [threads_count]; // consumer thread ID
38. // Create a producer thread
39. For (INT I = 0; I <producers_count; ++ I ){
40. Hthreads [I] = createthread (null, 0, producer, null, 0, & producerid [I]);
41. If (hthreads [I] = NULL) Return-1;
42. }
43. // Create a consumer thread
44. For (INT I = 0; I <consumers_count; ++ 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 () {// press enter to terminate the program running
51. G_continue = false;
52. }
53. }
55. Return 0;
56. }
58. // Produce a product. After a simple simulation, only the ID number of the new product is output.
59. Void produce ()
60. {
61. STD: cerr <"producing" <++ productid <"...";
62. STD: cerr <"succeed" <STD: Endl;
63. }
65. // Add the newly produced product to the buffer zone
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. // Output the current status of the buffer
74. For (INT I = 0; I <size_of_buffer; ++ I ){
75. STD: cout <I <":" <g_buffer [I];
76. If (I = In) STD: cout <"<-- production ";
77. If (I = out) STD: cout <"<-- consume ";
78. STD: cout <STD: Endl;
79. }
80. }
82. // Extract a product from the buffer
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. // Output the current status of the buffer
91. For (INT I = 0; I <size_of_buffer; ++ I ){
92. STD: cout <I <":" <g_buffer [I];
93. If (I = In) STD: cout <"<-- production ";
94. If (I = out) STD: cout <"<-- consume ";
95. STD: cout <STD: Endl;
96. }
97. }
99. // Consume one product
100. Void consume ()
101. {
102. STD: cerr <"consuming" <consumeid <"...";
103. STD: cerr <"succeed" <STD: Endl;
104. }
106. // Producer
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. // Consumer
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. }