"Go" implements multi-threaded mutex lock (WIN32) in C + +

Original Chexlong original address: http://blog.csdn.net/chexlong/article/details/7051193

Purpose of this article: to implement thread synchronization locks with C + + and Windows Mutex objects (mutexes).

Preparation knowledge: 1, the working mechanism of the kernel object mutex (mutex), the use of the WaitForSingleObject function, which can be obtained from MSDN, 2, when two or more threads need to access a shared resource at the same time, The system needs to use a synchronization mechanism to ensure that only one thread is using the resource at a time. A Mutex is a synchronization primitive that grants exclusive access to a shared resource to only one thread. If a thread acquires a mutex, the second thread to get the mutex is suspended until the first thread releases the mutex.

Below is my reference to the Open source project C + + sockets code, write the thread lock class

Lock.h

[CPP]View Plaincopy

2. #ifndef _lock_h
4. #define _lock_h
8. #include <windows.h>
12. Lock Interface Class
14. Class Imylock
16. {
18. Public
20. Virtual ~imylock () {}
24. virtual void Lock () const = 0;
26. virtual void Unlock () const = 0;
28. };
32. Mutex object Lock Class
34. Class Mutex: Public imylock
36. {
38. Public
40. Mutex ();
42. ~mutex ();
46. virtual void Lock () const;
48. virtual void Unlock () const;
52. Private
54. HANDLE M_mutex;
56. };
60. Lock
62. Class CLock
64. {
66. Public
68. CLock (const imylock&);
70. ~clock ();
74. Private
76. Const imylock& M_lock;
78. };
84. #endif

Lock.cpp

[CPP]View Plaincopy

2. #include "Lock.h"
6. Create an anonymous mutex object
8. Mutex::mutex ()
10. {
12. M_mutex =:: CreateMutex (NULL, FALSE, NULL);
14. }
18. Destroys mutex objects, frees resources
20. Mutex::~mutex ()
22. {
24. :: CloseHandle (M_mutex);
26. }
30. Ensure that the thread that owns the mutex has access to the protected resource on its own
32. void Mutex::lock () const
34. {
36. DWORD d = WaitForSingleObject (M_mutex, INFINITE);
38. }
42. Frees the mutex object owned by the current thread so that other threads can own the mutex and access the protected resource
44. void Mutex::unlock () const
46. {
48. :: ReleaseMutex (M_mutex);
50. }
54. Automatic lock-out with C + + features
56. Clock::clock (const imylock& m): M_lock (m)
58. {
60. M_lock. Lock ();
62. }
66. Automatic unlocking with C + + features
68. Clock::~clock ()
70. {
72. M_lock. Unlock ();
74. }

Below is the test code

[CPP]View Plaincopy

2. MyLock.cpp: Defines the entry point of the console application.
4. //
8. #include <iostream>
10. #include <process.h>
12. #include "Lock.h"
16. Using namespace std;
20. Create a Mutex object
22. Mutex G_lock;
28. Thread functions
30. unsigned int __stdcall startthread (void *pparam)
32. {
34. char *pmsg = (char *) pparam;
36. if (!pmsg)
38. {
40. return (unsigned int) 1;
42. }
46. //Lock the protected resource (the following print statement) automatically
48. //Before the thread function ends, automatically unlocks
50. CLock Lock (G_lock);
54. For ( int i = 0; i < 5; i++)
56. {
58. cout << pMsg << Endl;
60. Sleep (500);
62. }
66. return (unsigned int) 0;
68. }
72. int main (int argc, char* argv[])
74. {
76. HANDLE HThread1, hThread2;
78. unsigned int uiThreadId1, UITHREADID2;
82. char *PMSG1 = "First print thread.";
84. char *pmsg2 = "Second print Thread.";
88. //Create two worker threads, print different messages individually
92. //hthread1 =:: CreateThread (NULL, 0, (Lpthread_start_routine) Startthread, (void *) PMSG1, 0, (Lpdword) &  UITHREADID1);
94. //hthread2 =:: CreateThread (NULL, 0, (Lpthread_start_routine) Startthread, (void *) PMSG2, 0, (Lpdword) &  UITHREADID2);
98. HThread1 = (HANDLE) _beginthreadex (NULL, 0, &startthread, (void *) PMSG1, 0, &UITHREADID1);
100. HThread2 = (HANDLE) _beginthreadex (NULL, 0, &startthread, (void *) PMSG2, 0, &UITHREADID2);
104. //wait for thread to end
106. DWORD dwret = WaitForSingleObject (hthread1,infinite);
108. if (Dwret = = wait_timeout)
110. {
112. TerminateThread (hthread1,0);
114. }
116. Dwret = WaitForSingleObject (hthread2,infinite);
118. if (Dwret = = wait_timeout)
120. {
122. TerminateThread (hthread2,0);
124. }
128. //Close thread handle to release resources
130. :: CloseHandle (HTHREAD1);
132. :: CloseHandle (HTHREAD2);
136. System ("pause");
138. return 0;
140. }

Compile with VC2005, start the program, below is

If you stare at the code in the thread function, recompile the code, run

[CPP]View Plaincopy

1. CLock Lock (G_lock);

The results see

Thus, by using the encapsulation class of the mutex, we can achieve the purpose of multi-thread synchronization. Because a mutex belongs to a kernel object, it is slow to perform multi-threaded synchronization, but it can be synchronized between multiple threads in different processes with a mutex.

In practical applications, we usually use critical sections and critical_section, called Key code snippets, in the next blog, I'll add critical_section locks to the mutex and Critical_ The performance of the section is made to compare.

"Go" implements multi-threaded mutex lock (WIN32) in C + +