Turn---seconds to kill multithreading 11th reader Writer's question

As with the producer consumer Problem of the second multi-threaded tenth producer Consumer problem , reader writer is also a very famous synchronization problem. The reader writer's question description is very simple, there is a writer many readers, multiple readers can read the file at the same time, but the writer does not allow readers to write the file, the reader is also reading the file when the writer does not go to write files.

Above is the reader's question, similar to the analysis process of producer consumer problems, first to find out what is a "waiting" situation.

First The writer has to wait until there is no reader to write the file.

Second All readers have to wait for the writer to finish writing the file before they can read the file.

After looking for a "wait" situation, then see if there are any resources to mutually exclusive access. Since there is only one writer and the reader is able to share the read file, there is no resource that requires mutually exclusive access according to the topic. Similar to the beautiful color output in the previous article, we color-set the producer output code (see "VC console color Settings" in the console output color settings ). Therefore, there is a mutually exclusive access here, or it is likely that the reader thread will have output before the writer thread restores the console color settings. Therefore, to make a mutually exclusive access to the output statement, the modified reader and the writer's output functions are as follows:

[CPP]View Plaincopy

2. Reader thread output function
4. void readerprintf (char *pszformat, ...)
6. {
8. va_list parglist;
10. Va_start (Parglist, Pszformat);
12. EnterCriticalSection (&g_cs);
14. vfprintf (stdout, Pszformat, parglist);
16. LeaveCriticalSection (&g_cs);
18. Va_end (parglist);
20. }
22. Writer thread output function
24. void writerprintf (char *pszstr)
26. {
28. EnterCriticalSection (&g_cs);
30. Setconsolecolor (Foreground_green);
32. printf ("%s\n", pszstr);
34. Setconsolecolor (foreground_red | Foreground_green | Foreground_blue);
36. LeaveCriticalSection (&g_cs);
38. }

The variable parameters used by the reader thread output function are describedin using variable parameters in C,c++ .

resolves the mutex output problem and then considers how to implement the synchronization problem. You can set a variable to record the number of readers who are reading the file, and the first reader to begin reading the file will be responsible for closing the sign that allows the writer to enter, and the last reader to end the reading will be responsible for opening the sign that allows the writer to enter it. So the first kind of "wait" situation is solved. The second "Wait" situation is when a writer enters, so the reader cannot enter, and the task can be accomplished with an event--all readers are waiting for the event and the writer is responsible for triggering the event and setting the event as not triggered. See the code in detail for comments:

[CPP]View Plaincopy

2. Reader and writer questions
4. #include <stdio.h>
6. #include <process.h>
8. #include <windows.h>
10. Setting the console output color
12. BOOL Setconsolecolor (WORD wattributes)
14. {
16. HANDLE hconsole = GetStdHandle (Std_output_handle);
18. if (hconsole = = Invalid_handle_value)
20. return FALSE;
24. return Setconsoletextattribute (Hconsole, wattributes);
26. }
28. const INT reader_num = 5; //number of readers
30. Critical segments and events
32. critical_section G_cs, G_cs_writer_count;
34. HANDLE G_heventwriter, G_heventnoreader;
36. int g_nreadercount;
38. Reader thread output function (Implementation of variable parameter function)
40. void readerprintf (char *pszformat, ...)
42. {
44. va_list parglist;
48. Va_start (Parglist, Pszformat);
50. EnterCriticalSection (&g_cs);
52. vfprintf (stdout, Pszformat, parglist);
54. LeaveCriticalSection (&g_cs);
56. Va_end (parglist);
58. }
60. Reader thread functions
62. unsigned int __stdcall readerthreadfun (PVOID pM)
64. {
66. readerprintf ("%d reader entered wait ... \ n", GetCurrentThreadID ());
68. //Wait for the writer to complete
70. WaitForSingleObject (G_heventwriter, INFINITE);
74. //number of readers increased
76. EnterCriticalSection (&g_cs_writer_count);
78. g_nreadercount++;
80. if (G_nreadercount = = 1)
82. ResetEvent (G_heventnoreader);
84. LeaveCriticalSection (&g_cs_writer_count);
88. //Read file
90. readerprintf ("%d reader starts reading files ... \ n", GetCurrentThreadID ());
94. Sleep (rand ()% 100);
98. //End reading, number of readers decreased, vacancy increased
100. readerprintf ("%d reader ends reading file \ n", GetCurrentThreadID ());
104. //number of readers decreased
106. EnterCriticalSection (&g_cs_writer_count);
108. g_nreadercount--;
110. if (G_nreadercount = = 0)
112. SetEvent (G_heventnoreader);
114. LeaveCriticalSection (&g_cs_writer_count);
118. return 0;
120. }
122. Writer thread output function
124. void writerprintf (char *pszstr)
126. {
128. EnterCriticalSection (&g_cs);
130. Setconsolecolor (Foreground_green);
132. printf ("%s\n", pszstr);
134. Setconsolecolor (foreground_red | Foreground_green | Foreground_blue);
136. LeaveCriticalSection (&g_cs);
138. }
140. Writer thread functions
142. unsigned int __stdcall writerthreadfun (PVOID pM)
144. {
146. writerprintf ("writer thread enters wait ...");
148. //Waiting for the reader to read the file is zero
150. WaitForSingleObject (G_heventnoreader, INFINITE);
152. //Mark writer is writing file
154. ResetEvent (G_heventwriter);
158. //write file
160. writerprintf ("writer begins to write files ...");
162. Sleep (rand ()% 100);
164. writerprintf ("writer finishes writing documents");
168. //Mark writer end Write file
170. SetEvent (G_heventwriter);
172. return 0;
174. }
176. int main ()
178. {
180. printf ("reader Writer's question \ n");
182. printf ("-by Morewindows (http://blog.csdn.net/MoreWindows)--\n\n");
186. //Initialize events and semaphores
188. InitializeCriticalSection (&g_cs);
190. InitializeCriticalSection (&g_cs_writer_count);
194. //manual position, initial trigger
196. G_heventwriter = CreateEvent (null, True, true, null);
198. G_heventnoreader = CreateEvent (null, FALSE, TRUE, NULL);
200. G_nreadercount = 0;
204. int i;
206. HANDLE Hthread[reader_num + 1];
208. //Start two reader threads first
210. For (i = 1; I <= 2; i++)
212. Hthread[i] = (HANDLE) _beginthreadex (null, 0, readerthreadfun, NULL, 0, NULL);
214. //Start writer thread
216. Hthread[0] = (HANDLE) _beginthreadex (null, 0, writerthreadfun, NULL, 0, NULL);
218. Sleep (50);
220. ///finally start other reader processes
222. For (; I <= reader_num; i++)
224. Hthread[i] = (HANDLE) _beginthreadex (null, 0, readerthreadfun, NULL, 0, NULL);
226. WaitForMultipleObjects (Reader_num + 1, hthread, TRUE, INFINITE);
228. For (i = 0; i < Reader_num + 1; i++)
230. CloseHandle (Hthread[i]);
234. //Destroy events and semaphores
236. CloseHandle (G_heventwriter);
238. CloseHandle (G_heventnoreader);
240. DeleteCriticalSection (&g_cs);
242. DeleteCriticalSection (&g_cs_writer_count);
244. return 0;
246. }

The results of the operation are as follows:

The result shows that when a reader reads a file, the writer thread goes into the wait state. When the writer thread writes a file, the reader thread waits, indicating that the reader and the writer have completed the synchronization.

This series throughClassic thread Synchronization issuesto enumerate the key segments , events , mutexes , and semaphores of thread synchronization methods, And the four methods are summarized . Then through two well-known thread synchronization instance- producer consumer problem and reader writer problem to strengthen the understanding and application of multi-thread synchronization mutex. Hope that readers can master, so that in the written interview can be a smooth "second-kill" multi-threaded related questions, to obtain their own satisfactory offer .

From the second multi-threaded tenth producer consumer problem to the second-kill multi-threaded 11th reader writer Problem can be concluded that the key to multi-threaded problem is to find all the "wait" situation and determine whether there is no need for mutually exclusive access to resources. So how do you find these better, faster and more comprehensively from the actual problem? Take a look at the second multi-threaded 12th Multi- threaded synchronous internal Heart--PV operation and the second kill multithreading 13th Multi-threaded synchronous internal heart--PV operation  These two to strengthen the solution of multi-threaded synchronization problem "internal".

In addition, reader Writer's question can be solved with read-write lock srwlock, please see "second-order multi-threaded 14th reader Writer's question" Read and write lock Srwlock"

Reprint please indicate source, original address: http://blog.csdn.net/morewindows/article/details/7596034

Turn---seconds to kill multithreading 11th reader Writer's question