实现linux的互斥量c++封装

先贴示范代码：
//--------------------tmutex.h开始------------------------------
//实现linux的互斥量c++封装
#ifndef TMUTEX_H
#define TMUTEX_H
#include <pthread.h>
//线程互斥量
struct ThreadMutex
{
ThreadMutex()
{
pthread_mutex_init(&mtx,NULL);
}
~ThreadMutex()
{
pthread_mutex_destroy( &mtx );
}
inline void lock()
{
pthread_mutex_lock( &mtx );
}
inline void unlock()
{
pthread_mutex_unlock( &mtx );
}
pthread_mutex_t mtx;
};  
//空互斥量，即调用lock时什么事都不做。  
struct NullMutex
{
      inline void lock()  {   }  
 　  inline void unlock()  {  }  
};
template<class T>  class CAutoGuard  
{
public:
　　CAutoGuard(T &mtx) : m_mtx(mtx)
　　{
　　　　m_mtx.lock();
　　}
　　~CAutoGuard()
　　{
　　　　m_mtx.unlock();
　　}
protected:
　　T &m_mtx;
};

#define AUTO_GUARD( guard_tmp_var, MUTEX_TYPE, mtx ) \  
CAutoGuard<MUTEX_TYPE> guard_tmp_var(mtx)
#endif
//-------------------------tmutex.h结束------------------------------------------

//-------------------------主程序文件test.cpp开始---------------------------------
#include <pthread.h>
#include "tmutex.h"
#include <iostream>
using namespace std;

typedef ThreadMutex MUTEX_TYPE; //使用线程互斥量的互斥量类型
//typedef NullMutex MUTEX_TYPE; //不使用互斥量的互斥量类型

MUTEX_TYPE g_mtx; //互斥量变量定义
void *print_msg_thread(void *parg);

void *print_msg_thread(void *parg)
{//工作线程，用循环模拟一个的工作。
char *msg = (char *)parg;
AUTO_GUARD( gd, MUTEX_TYPE, g_mtx );
for(int i=0; i<10; i++ )
{
　　cout << msg << endl;
　　sleep( 1 );
}
return NULL;
}

int main()
{
pthread_t t1,t2;

//创建两个工作线程，第1个线程打印10个1，第2个线程打印10个2。
pthread_create( &t1, NULL, &print_msg_thread, (void *)"1" );
pthread_create( &t2, NULL, &print_msg_thread, (void *)"2" );

//等待线程结束
pthread_join( t1,NULL);
pthread_join( t2,NULL);
return 0;  
}
//-----------------------------主程序文件test.cpp结束
　　看了上面的示例代码及注释，相信已经了解该代码的功能。我们在主程序中创建两个线程，第1个线程循环打印10个1，第2个线程循环打印10个2。由于线程的特性，两个线程并不一定会按顺序执行，它们可能会被轮流调度执行。
　　如果两个线程被轮流调度执行，那么所打印的10个1和10个2的排列顺序则不固定。线程1打印了几个字符后，可能会别打断，CPU被分配到线程2上去执行。这样可以尽可能让每个线程都得到CPU资源。但是另一方面也带来了问题。如果两个线程共同访问了一个变量。并且两个线程都会修改它，在修改未完成被打断的话，会使得最后修改的结果和预期的不一致。对于不能被打断的操作我们叫它原子操作。为了能使线程中的某段代码成为原子操作，我们就得使用互斥量。如本例所示的打印10个字符，如果我们不使用互斥量那么这个打印顺序就会被破坏，使用了互斥量后，线程1未离开互斥量所管的区域，线程2是不能再次进入的。这就保证了打印过程的原子操作性。
　　Linux中使用临界区加锁的方法是用pthread_mutex_t进行操作，分别调用pthread_mutex_init、 pthread_mutex_destroy创建和释放pthread_mutex变量，调用pthread_mutex_lock和 pthread_mutex_unlock进行加锁和解锁。其中pthread_mutex_init和pthread_mutex_destroy只要在最开始的时候和不用的时候各调用一次，pthread_mutex_lock和pthread_mutex_unlock则是在每次加锁和解锁时调用。要注意的是它们的调用必须一一对应。
　　本例的互斥量使用了C++的构造和析构以及模板的特性进行封装，保证分配和释放、加锁和解锁的成对，使得互斥量的使用更加简单。加锁时只需一个语句：AUTO_GUARD( gd, MUTEX_TYPE, g_mtx ); 该语句是个宏，展开宏得到的代码是：CAutoGuard<MUTEX_TYPE> gd(g_mtx); CAutoGuard对象的构造和析构自动调用g_mtx的lock和unlock函数进行加锁解锁。而锁的类型就看MUTEX_TYPE的定义了。下面这两行是互斥量锁类型的定义：
typedef ThreadMutex MUTEX_TYPE; //使用线程互斥量的互斥量类型
//typedef NullMutex MUTEX_TYPE; //不使用互斥量的互斥量类型
　　其中第1行的类型是ThreadMutex，我们看该struct的定义，在lock和unlock函数中分别调用了pthread_mutex_lock和pthread_mutex_unlock，这样就实现了资源的锁定和解锁。
　　而第2行的类型是NullMutex，在该struct的定义中，lock和unlock函数都是空函数，没有执行任何锁定解锁操作。
　　因此，将MUTEX_TYPE的类型改为ThreadMutex或NullMutex就可以实现使用或不使用互斥量的效果。
　　将上述两个文件保存并编译：g++ tmutex.h test.cpp -lpthread -o test
　　编译完输出test可执行文件。输入./test执行程序。下面是使用互斥量和不使用互斥量的执行结果：

使用互斥量：
[root@hjclinux sampthread]# g++ tmutex.h test.cpp -lpthread -o test
[root@hjclinux sampthread]# ./test
11111111112222222222
将test.cpp中的MUTEX_TYPE定义改成typedef NullMutex MUTEX_TYPE再编译执行结果如下：
[root@hjclinux sampthread]# ./test
12212121212121212121
由于线程调度的关系，可能每次执行打印出1和2的顺序都不一样。