先貼示范代碼：
//--------------------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
1
1
1
1
1
1
1
1
1
1
2
2
2
2
2
2
2
2
2
2
將test.cpp中的MUTEX_TYPE定義改成typedef NullMutex MUTEX_TYPE再編譯執行結果如下：
[root@hjclinux sampthread]# ./test
1
2
2
1
2
1
2
1
2
1
2
1
2
1
2
1
2
1
2
1
由于線程調度的關系，可能每次執行打印出1和2的順序都不一樣。