Turn---seconds to kill multithreading 14th reader Writer's question following read/write lock Srwlock

We use events and a variable that records the number of readers to solve reader-writer problems in the second-to-last multi-threaded 11th article Reader-writer question. The problem has been solved, but the code is a bit complicated. This article will introduce a new method-read-write lock srwlock to solve this problem. read-write locks also distinguish between the thread that wants to read the resource value (the reader thread) and the thread that wants to update the resource (the writer thread) while protecting the resource. For reader threads, read-write locks allow them to execute concurrently. When a writer thread occupies a resource, the read-write lock causes the other writer thread and reader thread to wait. So using a read-write lock to solve reader-writer problems can make the code very clear and concise.

Here's a look at how to use read and write locks, note that compiling a read-write lock program requires VS2008, and running a read-write lock program on a Vista or Windows Server2008 system (more than these two more advanced systems can). The main function of the read-write lock is five, which is divided into initialization function, writer thread request and release function, reader thread request and release function, the following is the detailed function instruction:

The first of the initializesrwlock

function function: Initialize read-write lock

Function prototype:VOID initializesrwlock(psrwlock SRWLock);

Function Description: Initialize (without deleting or destroying Srwlock functions, the system will automatically clean up)

A second acquiresrwlockexclusive

function function: Writer thread request write resource.

Function prototype:VOID acquiresrwlockexclusive(psrwlock SRWLock);

A third releasesrwlockexclusive

function function: The writer thread writes the resource complete and frees up the resource usage.

Function prototype:VOID releasesrwlockexclusive(psrwlock SRWLock);

Fourth one acquiresrwlockshared

function function: Reader thread request read resource.

Function prototype:VOID acquiresrwlockshared(psrwlock SRWLock);

Fifth one releasesrwlockshared

function function: The reader thread ends reading the resource and frees up the resource.

Function prototype:VOID releasesrwlockshared(psrwlock SRWLock);

Note A thread can only lock resources once and cannot lock resources multiple times.

Use the read-write lock to refine the code as follows (the implementation of the variable parameter function in the code is described in "using variable parameters in c,c++", console color settings See "VC Console Color Settings"):

[CPP]View Plaincopy

2. Reader and writer's question secondary read-write lock Srwlock
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;
22. return Setconsoletextattribute (Hconsole, wattributes);
24. }
26. const INT reader_num = 5; //number of readers
28. Critical segments and events
30. Critical_section G_cs;
32. SRWLOCK G_srwlock;
34. Reader thread output function (Implementation of variable parameter function)
36. void readerprintf (char *pszformat, ...)
38. {
40. va_list parglist;
42. Va_start (Parglist, Pszformat);
44. EnterCriticalSection (&g_cs);
46. vfprintf (stdout, Pszformat, parglist);
48. LeaveCriticalSection (&g_cs);
50. Va_end (parglist);
52. }
54. Reader thread functions
56. unsigned int __stdcall readerthreadfun (PVOID pM)
58. {
60. readerprintf ("%d reader entered wait ... \ n", GetCurrentThreadID ());
62. //Reader request to read files
64. Acquiresrwlockshared (&g_srwlock);
68. //Read file
70. readerprintf ("%d reader starts reading files ... \ n", GetCurrentThreadID ());
72. Sleep (rand ()% 100);
74. readerprintf ("%d reader ends reading file \ n", GetCurrentThreadID ());
78. //Reader end read File
80. Releasesrwlockshared (&g_srwlock);
82. return 0;
84. }
86. Writer thread output function
88. void writerprintf (char *pszstr)
90. {
92. EnterCriticalSection (&g_cs);
94. Setconsolecolor (Foreground_green);
96. printf ("%s\n", pszstr);
98. Setconsolecolor (foreground_red | Foreground_green | Foreground_blue);
100. LeaveCriticalSection (&g_cs);
102. }
104. Writer thread functions
106. unsigned int __stdcall writerthreadfun (PVOID pM)
108. {
110. writerprintf ("writer thread enters wait ...");
112. //writer apply to write file
114. Acquiresrwlockexclusive (&g_srwlock);
118. //write file
120. writerprintf ("writer begins to write files ...");
122. Sleep (rand ()% 100);
124. writerprintf ("writer finishes writing documents");
128. //Mark writer end Write file
130. Releasesrwlockexclusive (&g_srwlock);
132. return 0;
134. }
136. int main ()
138. {
140. printf ("reader writer Problem srwlock\n");
142. printf ("-by Morewindows (http://blog.csdn.net/MoreWindows)--\n\n");
146. //Initialize read-write lock and key segment
148. InitializeCriticalSection (&g_cs);
150. Initializesrwlock (&g_srwlock);
154. HANDLE Hthread[reader_num + 1];
156. int i;
158. //Start two reader threads first
160. For (i = 1; I <= 2; i++)
162. Hthread[i] = (HANDLE) _beginthreadex (null, 0, readerthreadfun, NULL, 0, NULL);
164. //Start writer thread
166. Hthread[0] = (HANDLE) _beginthreadex (null, 0, writerthreadfun, NULL, 0, NULL);
168. Sleep (50);
170. ///finally start other reader processes
172. For (; I <= reader_num; i++)
174. Hthread[i] = (HANDLE) _beginthreadex (null, 0, readerthreadfun, NULL, 0, NULL);
176. WaitForMultipleObjects (Reader_num + 1, hthread, TRUE, INFINITE);
178. For (i = 0; i < Reader_num + 1; i++)
180. CloseHandle (Hthread[i]);
184. //Destroy critical segment
186. DeleteCriticalSection (&g_cs);
188. return 0;
190. }

In contrast to the " second-kill multithreaded 11th reader writer Problem " in the code can be found that the code is indeed a lot more refreshing. This program can be compiled with VS2008, but running under the XP system will result in an error.

In the Win7 system can be run correctly, the result:

Finally summarize the read-write lock SRWLock

1. Read-write locks are initialized after they are declared, but not destroyed, and the system automatically cleans up read and write locks.

2. The reader and writer call different application functions and release functions, respectively.

Turn---seconds to kill multithreading 14th reader Writer's question following read/write lock Srwlock