在上篇用C++实现了Win32平台上的多线程互斥锁( 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

测试代码
 
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