Linux多線程及臨界區編程例解

先貼示範代碼：

//--------------------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的順序都不一樣。