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

原作者：chexlong 原文地址：http://blog.csdn.net/chexlong/article/details/7058283

在上篇用C++实现了Win32平台上的多线程互斥锁，这次写个Linux平台上的，同样参考了开源项目C++ Sockets的代码，在此对这些给开源项目做出贡献的斗士们表示感谢！

下边分别是互斥锁类和测试代码，已经在Fedora 13虚拟机上测试通过。

Lock.h

[cpp] view plaincopy

1. #ifndef _Lock_H
2. #define _Lock_H
3. #include <pthread.h>
4. //锁接口类
5. class ILock
6. {
7. public:
8. virtual ~ILock() {}
9. virtual void Lock() const = 0;
10. virtual void Unlock() const = 0;
11. };
12. //互斥锁类
13. class CMutex : public ILock
14. {
15. public:
16. CMutex();
17. ~CMutex();
18. virtual void Lock() const;
19. virtual void Unlock() const;
20. private:
21. mutable pthread_mutex_t m_mutex;
22. };
23. //锁
24. class CMyLock
25. {
26. public:
27. CMyLock(const ILock&);
28. ~CMyLock();
29. private:
30. const ILock& m_lock;
31. };
32. #endif

Lock.cpp

[cpp] view plaincopy

1. #include "Lock.h"
2. //动态方式初始化互斥锁
3. CMutex::CMutex()
4. {
5. pthread_mutex_init(&m_mutex, NULL);
6. }
7. //注销互斥锁
8. CMutex::~CMutex()
9. {
10. pthread_mutex_destroy(&m_mutex);
11. }
12. //确保拥有互斥锁的线程对被保护资源的独自访问
13. void CMutex::Lock() const
14. {
15. pthread_mutex_lock(&m_mutex);
16. }
17. //释放当前线程拥有的锁，以使其它线程可以拥有互斥锁，对被保护资源进行访问
18. void CMutex::Unlock() const
19. {
20. pthread_mutex_unlock(&m_mutex);
21. }
22. //利用C++特性，进行自动加锁
23. CMyLock::CMyLock(const ILock& m) : m_lock(m)
24. {
25. m_lock.Lock();
26. }
27. //利用C++特性，进行自动解锁
28. CMyLock::~CMyLock()
29. {
30. m_lock.Unlock();
31. }

测试代码

[cpp] view plaincopy

1. // pthread_mutex.cpp : 定义控制台应用程序的入口点。
2. //
3. #include <iostream>
4. #include <unistd.h>
5. #include "Lock.h"
6. using namespace std;
7. //创建一个互斥锁
8. CMutex g_Lock;
9. //线程函数
10. void * StartThread(void *pParam)
11. {
12. char *pMsg = (char *)pParam;
13. if (!pMsg)
14. {
15. return (void *)1;
16. }
17. //对被保护资源（以下打印语句）自动加锁
18. //线程函数结束前，自动解锁
19. CMyLock lock(g_Lock);
20. for( int i = 0; i < 5; i++ )
21. {
22. cout << pMsg << endl;
23. sleep( 1 );
24. }
25. return (void *)0;
26. }
27. int main(int argc, char* argv[])
28. {
29. pthread_t thread1,thread2;
30. pthread_attr_t attr1,attr2;
31. char *pMsg1 = "First print thread.";
32. char *pMsg2 = "Second print thread.";
33. //创建两个工作线程，分别打印不同的消息
34. pthread_attr_init(&attr1);
35. pthread_attr_setdetachstate(&attr1,PTHREAD_CREATE_JOINABLE);
36. if (pthread_create(&thread1,&attr1, StartThread,pMsg1) == -1)
37. {
38. cout<<"Thread 1: create failed"<<endl;
39. }
40. pthread_attr_init(&attr2);
41. pthread_attr_setdetachstate(&attr2,PTHREAD_CREATE_JOINABLE);
42. if (pthread_create(&thread2,&attr2, StartThread,pMsg2) == -1)
43. {
44. cout<<"Thread 2: create failed"<<endl;
45. }
46. //等待线程结束
47. void *result;
48. pthread_join(thread1,&result);
49. pthread_join(thread2,&result);
50. //关闭线程，释放资源
51. pthread_attr_destroy(&attr1);
52. pthread_attr_destroy(&attr2);
53. int iWait;
54. cin>>iWait;
55. return 0;
56. }

编译成功后，运行程序

同样，若将下边代码注释掉，重新编译

[cpp] view plaincopy

1. //CMyLock lock(g_Lock);

运行程序

结果显而易见。