Implementing multi-threaded mutexes with C + + on the "Go" Linux Platform

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

In the previous article in C + + implementation of the WIN32 platform on the multi-threaded mutex, this time to write a Linux platform, the same reference to the Open source project C + + sockets code, in this to the open source projects to contribute to the Warriors to express gratitude!

Below are mutually exclusive lock classes and test codes, which have been tested on Fedora 13 virtual machines.

Lock.h

[CPP]View Plaincopy

2. #ifndef _lock_h
4. #define _lock_h
8. #include <pthread.h>
12. Lock Interface Class
14. Class ILock
16. {
18. Public
20. Virtual ~ilock () {}
24. virtual void Lock () const = 0;
26. virtual void Unlock () const = 0;
28. };
32. Mutex Lock class
34. Class CMutex: Public ILock
36. {
38. Public
40. CMutex ();
42. ~cmutex ();
46. virtual void Lock () const;
48. virtual void Unlock () const;
52. Private
54. mutable pthread_mutex_t M_mutex;
56. };
60. Lock
62. Class Cmylock
64. {
66. Public
68. Cmylock (const ilock&);
70. ~cmylock ();
74. Private
76. Const ilock& M_lock;
78. };
84. #endif

Lock.cpp

[CPP]View Plaincopy

2. #include "Lock.h"
8. Dynamic initialization of Mutex locks
10. Cmutex::cmutex ()
12. {
14. Pthread_mutex_init (&m_mutex, NULL);
16. }
20. Unregister a mutex lock
22. Cmutex::~cmutex ()
24. {
26. Pthread_mutex_destroy (&m_mutex);
28. }
32. Ensure that the thread that owns the mutex accesses the protected resource on its own
34. void Cmutex::lock () const
36. {
38. Pthread_mutex_lock (&m_mutex);
40. }
44. Frees the lock owned by the current thread so that other threads can have a mutex to access the protected resource
46. void Cmutex::unlock () const
48. {
50. Pthread_mutex_unlock (&m_mutex);
52. }
56. Automatic lock-out with C + + features
58. Cmylock::cmylock (const ilock& m): M_lock (m)
60. {
62. M_lock. Lock ();
64. }
68. Automatic unlocking with C + + features
70. Cmylock::~cmylock ()
72. {
74. M_lock. Unlock ();
76. }

Test code

[CPP]View Plaincopy

2. Pthread_mutex.cpp: Defines the entry point of the console application.
4. //
8. #include <iostream>
10. #include <unistd.h>
12. #include "Lock.h"
16. Using namespace std;
20. Create a mutex lock
22. CMutex G_lock;
28. Thread functions
30. void * Startthread (void *pparam)
32. {
34. char *pmsg = (char *) pparam;
36. if (!pmsg)
38. {
40. return (void *) 1;
42. }
46. //Lock the protected resource (the following print statement) automatically
48. //Before the thread function ends, automatically unlocks
50. Cmylock Lock (G_lock);
54. For ( int i = 0; i < 5; i++)
56. {
58. cout << pMsg << Endl;
60. Sleep (1);
62. }
66. return (void *) 0;
68. }
72. int main (int argc, char* argv[])
74. {
76. pthread_t thread1,thread2;
78. pthread_attr_t attr1,attr2;
82. char *PMSG1 = "First print thread.";
84. char *pmsg2 = "Second print Thread.";
88. //Create two worker threads, print different messages individually
90. Pthread_attr_init (&ATTR1);
92. Pthread_attr_setdetachstate (&attr1,pthread_create_joinable);
94. if (pthread_create (&THREAD1,&ATTR1, STARTTHREAD,PMSG1) = =-1)
96. {
98. cout<<"Thread 1:create failed" <<endl;
100. }
102. Pthread_attr_init (&ATTR2);
104. Pthread_attr_setdetachstate (&attr2,pthread_create_joinable);
106. if (pthread_create (&THREAD2,&ATTR2, startthread,pmsg2) = =-1)
108. {
110. cout<<"Thread 2:create failed" <<endl;
112. }
116. //wait for thread to end
118. void *result;
120. Pthread_join (Thread1,&result);
122. Pthread_join (Thread2,&result);
126. //Close thread, release resources
128. Pthread_attr_destroy (&ATTR1);
130. Pthread_attr_destroy (&ATTR2);
134. int iwait;
136. cin>>iwait;
140. return 0;
142. }

after the compilation is successful, run the program

Similarly, if you comment out the code below, recompile

[CPP]View Plaincopy

1. Cmylock Lock (G_lock);

Run the program

The results are obvious.

Implementing multi-threaded mutexes with C + + on the "Go" Linux Platform