Linux平台上用C++实现多线程互斥锁

向右看齐 2022-06-10 00:26 168阅读 0赞

在上篇用C++实现了Win32平台上的多线程互斥锁( [ http://www.linuxidc.com/Linux/2011-12/49713.htm][http_www.linuxidc.com_Linux_2011-12_49713.htm] )，这次写个Linux平台上的，同样参考了开源项目C++ Sockets的代码，在此对这些给开源项目做出贡献的斗士们表示感谢！  
  
下边分别是互斥锁类和测试代码，已经在Fedora 13虚拟机上测试通过。

Lock.h  
1.\#ifndef \_Lock\_H  
2.\#define \_Lock\_H  
3.  
4.\#include <pthread.h>  
5.  
6.//锁接口类  
7.class ILock  
8.\{  
9.public:  
10. virtual ~ILock() \{\}  
11.  
12. virtual void Lock() const = 0;  
13. virtual void Unlock() const = 0;  
14.\};  
15.  
16.//互斥锁类  
17.class CMutex : public ILock  
18.\{  
19.public:  
20. CMutex();  
21. ~CMutex();  
22.  
23. virtual void Lock() const;  
24. virtual void Unlock() const;  
25.  
26.private:  
27. mutable pthread\_mutex\_t m\_mutex;  
28.\};  
29.  
30.//锁  
31.class CMyLock  
32.\{  
33.public:  
34. CMyLock(const ILock&);  
35. ~CMyLock();  
36.  
37.private:  
38. const ILock& m\_lock;  
39.\};  
40.  
41.  
42.\#endif  
  
Lock.cpp  
  
1.\#include "Lock.h"  
2.  
3.  
4.//动态方式初始化互斥锁  
5.CMutex::CMutex()  
6.\{  
7. pthread\_mutex\_init(&m\_mutex, NULL);  
8.\}  
9.  
10.//注销互斥锁  
11.CMutex::~CMutex()  
12.\{  
13. pthread\_mutex\_destroy(&m\_mutex);  
14.\}  
15.  
16.//确保拥有互斥锁的线程对被保护资源的独自访问  
17.void CMutex::Lock() const  
18.\{  
19. pthread\_mutex\_lock(&m\_mutex);  
20.\}  
21.  
22.//释放当前线程拥有的锁，以使其它线程可以拥有互斥锁，对被保护资源进行访问  
23.void CMutex::Unlock() const  
24.\{  
25. pthread\_mutex\_unlock(&m\_mutex);  
26.\}  
27.  
28.//利用C++特性，进行自动加锁  
29.CMyLock::CMyLock(const ILock& m) : m\_lock(m)  
30.\{  
31. m\_lock.Lock();  
32.\}  
33.  
34.//利用C++特性，进行自动解锁  
35.CMyLock::~CMyLock()  
36.\{  
37. m\_lock.Unlock();  
38.\}

本篇文章来源于 Linux公社网站([www.linuxidc.com][]) 原文链接：[http://www.linuxidc.com/Linux/2011-12/49714.htm][http_www.linuxidc.com_Linux_2011-12_49714.htm]

测试代码  
  
1.// pthread\_mutex.cpp : 定义控制台应用程序的入口点。  
2.//  
3.  
4.\#include <iostream>  
5.\#include <unistd.h>  
6.\#include "Lock.h"  
7.  
8.using namespace std;  
9.  
10.//创建一个互斥锁  
11.CMutex g\_Lock;  
12.  
13.  
14.//线程函数  
15.void \* StartThread(void \*pParam)  
16.\{  
17. char \*pMsg = (char \*)pParam;  
18. if (!pMsg)  
19. \{  
20. return (void \*)1;  
21. \}  
22.  
23. //对被保护资源（以下打印语句）自动加锁  
24. //线程函数结束前，自动解锁  
25. CMyLock lock(g\_Lock);  
26.  
27. for( int i = 0; i < 5; i++ )  
28. \{  
29. cout << pMsg << endl;  
30. sleep( 1 );  
31. \}  
32.  
33. return (void \*)0;  
34.\}  
35.  
36.int main(int argc, char\* argv\[\])  
37.\{  
38. pthread\_t thread1,thread2;  
39. pthread\_attr\_t attr1,attr2;  
40.  
41. char \*pMsg1 = "First print thread.";  
42. char \*pMsg2 = "Second print thread.";  
43.  
44. //创建两个工作线程，分别打印不同的消息  
45. pthread\_attr\_init(&attr1);  
46. pthread\_attr\_setdetachstate(&attr1,PTHREAD\_CREATE\_JOINABLE);  
47. if (pthread\_create(&thread1,&attr1, StartThread,pMsg1) == -1)  
48. \{  
49. cout<<"Thread 1: create failed"<<endl;  
50. \}  
51. pthread\_attr\_init(&attr2);  
52. pthread\_attr\_setdetachstate(&attr2,PTHREAD\_CREATE\_JOINABLE);  
53. if (pthread\_create(&thread2,&attr2, StartThread,pMsg2) == -1)  
54. \{  
55. cout<<"Thread 2: create failed"<<endl;  
56. \}  
57.  
58. //等待线程结束  
59. void \*result;  
60. pthread\_join(thread1,&result);  
61. pthread\_join(thread2,&result);  
62.  
63. //关闭线程，释放资源  
64. pthread\_attr\_destroy(&attr1);  
65. pthread\_attr\_destroy(&attr2);  
66.  
67. int iWait;  
68. cin>>iWait;  
69.  
70. return 0;  
71.\}  
  
  
编译成功后，运行程序

同样，若将下边代码注释掉，重新编译  
  
1.//CMyLock lock(g\_Lock);  
  
运行程序

结果显而易见。

本篇文章来源于 Linux公社网站([www.linuxidc.com][]) 原文链接：[http://www.linuxidc.com/Linux/2011-12/49714p2.htm][http_www.linuxidc.com_Linux_2011-12_49714p2.htm]

[http_www.linuxidc.com_Linux_2011-12_49713.htm]: http://www.linuxidc.com/Linux/2011-12/49713.htm
[www.linuxidc.com]: http://www.linuxidc.com
[http_www.linuxidc.com_Linux_2011-12_49714.htm]: http://www.linuxidc.com/Linux/2011-12/49714.htm
[http_www.linuxidc.com_Linux_2011-12_49714p2.htm]: http://www.linuxidc.com/Linux/2011-12/49714p2.htm