5.3.2 常用同步類 · 深入理解Android：卷1

同步，是多線程編程中不可回避的話題，同時也是一個非常復雜的問題。這里，只簡單介紹一下Android提供的同步類。這些類，只對系統提供的多線程同步函數（這種函數我們也稱之為Raw API）進行了面向對象的封裝，讀者必須先理解Raw API，然后才能真正掌握其具體用法。 * * * * * **提示**：了解Windows下的多線程編程，有很多參考資料，但我以為，現在先學習MSDN就可以了。有關Linux下完整系統闡述多線程編程的書籍目前較少，這里推薦一本含金量較高的著作《Programmingwith POSIX Thread》（本書只有英文版的，由Addison-Wesley出版）。 * * * * * Android提供了兩個封裝好的同步類，它們是Mutex和Condition。這是重量級的同步技術，一般內核會有對應的支持。另外，OS還提供了簡單的原子操作，這些也算是同步技術的一種。下面分別來介紹這三種東西。 1. 互斥類——Mutex Mutex是互斥類，用于多線程訪問同一個資源的時候，保證一次只能有一個線程能訪問該資源。在《Windows核心編程》一書中，對于這種互斥訪問有一個很形象的比喻：想象你在飛機上如廁，這時衛生間的信息牌上顯示“有人”，你必須等里邊的人出來后才可進去。這就是互斥的含義。下面來看Mutex的實現方式，它們都很簡單。（1）Mutex介紹其代碼如下所示： **Thread.h::Mutex的聲明和實現** ~~~ inline Mutex::Mutex(int type, const char* name){ if(type == SHARED) { //type如果是SHARED，則表明這個Mutex支持跨進程的線程同步 //以后我們在Audio系統和Surface系統中會經常見到這種用法 pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); pthread_mutex_init(&mMutex, &attr); pthread_mutexattr_destroy(&attr); } else { pthread_mutex_init(&mMutex, NULL); } } inline Mutex::~Mutex() { pthread_mutex_destroy(&mMutex); } inline status_t Mutex::lock() { return-pthread_mutex_lock(&mMutex); } inline void Mutex::unlock() { pthread_mutex_unlock(&mMutex); } inline status_t Mutex::tryLock() { return-pthread_mutex_trylock(&mMutex); } ~~~ 關于Mutex的使用，除了初始化外，最重要的是lock和unlock函數的使用，它們的用法如下： - 要想獨占衛生間，必須先調用Mutex的lock函數。這樣，這個區域就被鎖住了。如果這塊區域之前已被別人鎖住，lock函數則會等待，直到可以進入這塊區域為止。系統保證一次只有一個線程能lock成功。 - 當你“方便”完畢，記得調用Mutex的unlock以釋放互斥區域。這樣，其他人的lock才可以成功返回。 - 另外，Mutex還提供了一個trylock函數，該函數只是嘗試去鎖住該區域，使用者需要根據trylock的返回值判斷是否成功鎖住了該區域。 * * * * * **注意**：以上這些內容都和Raw API有關，不了解它的讀者可自行學習與它相關的知識。在Android系統中，多線程也是常見和重要的編程手段，務請大家重視。 * * * * * Mutex類確實比Raw API方便好用，不過還是稍顯麻煩。來看下一節。（2）AutoLock介紹 AutoLock類是定義在Mutex內部的一個類，它其實是一幫“懶人”搞出來的，為什么這么說呢？先來看看使用Mutex夠多麻煩： - 顯示調用Mutex的lock。 - 在某個時候要記住調用該Mutex的unlock。以上這些操作都必須一一對應，否則會出現“死鎖”！有些代碼中，在判斷分支特別多的情況下，unlock這句代碼被寫得比比皆是，如稍有不慎，在某處就會忘寫了它。有什么好辦法能解決這個問題嗎？終于有人想出來一個好辦法，就是充分利用了C++的構造和析構函數，只需一看AutoLock的定義就會明白。代碼如下所示： **Thread.h Mutex::Autolock聲明和實現** ~~~ classAutolock { public: //構造的時候調用lock inline Autolock(Mutex& mutex) : mLock(mutex) { mLock.lock(); } inline Autolock(Mutex* mutex) : mLock(*mutex) { mLock.lock(); } //析構的時候調用unlock inline ~Autolock() { mLock.unlock(); } private: Mutex& mLock; }; ~~~ AutoLock的用法很簡單： - 先定義一個Mutex，如 Mutex xlock； - 在使用xlock的地方，定義一個AutoLock，如 AutoLock autoLock（xlock）。由于C++對象的構造和析構函數都是自動被調用的，所以在AutoLock的生命周期內，xlock的lock和unlock也就自動被調用了，這樣就省去了重復書寫unlock的麻煩，而且lock和unlock的調用肯定是一一對應的，這樣就絕對不會出錯。 2. 條件類——Condition 多線程同步中的條件類對應的是下面一種使用場景： - 線程A做初始化工作，而其他線程比如線程B、C必須等到初始化工作完后才能工作，即線程B、C在等待一個條件，我們稱B、C為等待者。 - 當線程A完成初始化工作時，會觸發這個條件，那么等待者B、C就會被喚醒。觸發這個條件的A就是觸發者。上面的使用場景非常形象，而且條件類提供的函數也非常形象，它的代碼如下所示： **Thread.h::Condition的聲明和實現** ~~~ class Condition { public: enum { PRIVATE = 0, SHARED = 1 }; Condition(); Condition(int type);//如果type是SHARED，表示支持跨進程的條件同步 ~Condition(); //線程B和C等待事件，wait這個名字是不是很形象呢？ status_t wait(Mutex& mutex); //線程B和C的超時等待，B和C可以指定等待時間，當超過這個時間，條件卻還不滿足，則退出等待 status_t waitRelative(Mutex& mutex, nsecs_t reltime); //觸發者A用來通知條件已經滿足，但是B和C只有一個會被喚醒 voidsignal(); //觸發者A用來通知條件已經滿足，所有等待者都會被喚醒 voidbroadcast(); private: #if defined(HAVE_PTHREADS) pthread_cond_t mCond; #else void* mState; #endif } ~~~ 聲明很簡單，定義也很簡單，代碼如下所示： ~~~ inline Condition::Condition() { pthread_cond_init(&mCond, NULL); } inline Condition::Condition(int type) { if(type == SHARED) {//設置跨進程的同步支持 pthread_condattr_t attr; pthread_condattr_init(&attr); pthread_condattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); pthread_cond_init(&mCond, &attr); pthread_condattr_destroy(&attr); } else{ pthread_cond_init(&mCond, NULL); } } inline Condition::~Condition() { pthread_cond_destroy(&mCond); } inline status_t Condition::wait(Mutex&mutex) { return-pthread_cond_wait(&mCond, &mutex.mMutex); } inline status_tCondition::waitRelative(Mutex& mutex, nsecs_t reltime) { #if defined(HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE) structtimespec ts; ts.tv_sec = reltime/1000000000; ts.tv_nsec = reltime%1000000000; return-pthread_cond_timedwait_relative_np(&mCond, &mutex.mMutex, &ts); ...... //有些系統沒有實現POSIX的相關函數，所以不同系統需要調用不同的函數 #endif } inline void Condition::signal() { pthread_cond_signal(&mCond); } inline void Condition::broadcast() { pthread_cond_broadcast(&mCond); } ~~~ 可以看出，Condition的實現全是憑借調用了Raw API的pthread_cond_xxx函數。這里要重點說明的是，Condition類必須配合Mutex來使用。什么意思？ - 上面代碼中，不論是wait、waitRelative、signal還是broadcast的調用，都放在一個Mutex的lock和unlock范圍中，尤其是wait和waitRelative函數的調用，這是強制性的。來看一個實際的例子，加深一下對Condition類和Mutex類使用的印象。這個例子是Thread類的requestExitAndWait，目的是等待工作線程退出，代碼如下所示： **Thread.cpp** ~~~ status_t Thread::requestExitAndWait() { ...... requestExit();//設置退出變量mExitPending為true Mutex::Autolock_l(mLock);//使用Autolock，mLock被鎖住 while(mRunning == true) { /* 條件變量的等待，這里為什么要通過while循環來反復檢測mRunning？因為某些時候即使條件類沒有被觸發，wait也會返回。關于這個問題，強烈建議讀者閱讀前邊推薦的《Programming with POSIX Thread》一書。 */ mThreadExitedCondition.wait(mLock); } mExitPending = false; //退出前，局部變量Mutex::Autolock _l的析構會被調用，unlock也就會被自動調用。 returnmStatus; } ~~~ 那么，什么地方會觸發這個條件呢？是在工作線程退出前。其代碼如下所示： **Thread.cpp** ~~~ int Thread::_threadLoop(void* user) { Thread* const self =static_cast<Thread*>(user); sp<Thread> strong(self->mHoldSelf); wp<Thread> weak(strong); self->mHoldSelf.clear(); do { ...... result= self->threadLoop();//調用子類的threadLoop函數 ...... //如果mExitPending為true，則退出 if(result == false || self->mExitPending) { self->mExitPending = true; //退出前觸發條件變量，喚醒等待者 self->mLock.lock();//lock鎖住 //mRunning的修改位于鎖的保護中。如果你閱讀了前面推薦的書，這里也就不難理解了 self->mRunning = false; self->mThreadExitedCondition.broadcast(); self->mLock.unlock();//釋放鎖 break;//退出循環，此后該線程函數會退出 } ...... }while(strong != 0); return0; } ~~~ 關于Android多線程的同步類，暫時介紹到此吧。當然，這些類背后所隱含的知識及技術是讀者需要倍加重視的。希望我們能養成一種由點及面的學習方法。以我們的同步類為例，假設你是第一次接觸多線程編程，也學會了如何使用Mutex和Condition這兩個類，不妨以這兩個類代碼中所傳遞的知識做為切入點，把和多線程相關的所有知識（這個知識不僅僅是函數的使用，還包括多線程的原理，多線程的編程模型，甚至是現在很熱門的并行多核編程）普遍了解一下。只有深刻理解并掌握了原理等基礎和框架性的知識，才能以不變應萬變，才能做到游刃有余。 3. 原子操作函數介紹什么是原子操作？所謂原子操作，就是該操作絕不會在執行完畢前被任何其他任務或事件打斷，也就說，原子操作是最小的執行單位。上面這句話放到代碼中是什么意思？請看一個例子： **例子** ~~~ static int g_flag = 0; //全局變量g_flag static Mutex lock ;//全局的鎖 //線程1執行thread1 void thread1() { //g_flag遞減,每次操作前鎖住 lock.lock(); g_flag--; lock.unlock(); } //線程2中執行thread2函數 void thread2() { lock.lock(); g_flag++; //線程2對g_flag進行遞增操作，每次操作前要取得鎖 lock.unlock(); } ~~~ 為什么需要Mutex來幫忙呢？因為g_flags++或者g_flags—操作都不是原子操作。從匯編指令的角度看，C/C++中的一條語句對應了數條匯編指令。以g_flags++操作為例，它生成的匯編指令可能就是以下三條： - 從內存中取數據到寄存器。 - 對寄存器中的數據進行遞增操作，結果還在寄存器中。 - 寄存器的結果寫回內存。這三條匯編指令，如果按正常的順序連續執行，是沒有問題的，但在多線程時就不能保證了。例如，線程1在執行第一條指令后，線程2由于調度的原因，搶先在線程1之前連續執行完了三條指令。這樣，線程1繼續執行指令時，它所使用的值就不是線程2更新后的值，而是之前的舊值。再對這個值進行操作便沒有意義了。在一般情況下，處理這種問題可以使用Mutex來加鎖保護，但Mutex的使用比它所要保護的內容還復雜，例如，鎖的使用將導致從用戶態轉入內核態，有較大的浪費。那么，有沒有簡便些的辦法讓這些加、減等操作不被中斷呢？答案是肯定的，但這需要CPU的支持。在X86平臺上，一個遞增操作可以用下面的內嵌匯編語句實現： ~~~ #define LOCK "lock;" INT32 InterlockedIncrement(INT32* lpAddend) { /* 這是我們在Linux平臺上實現Windows API時使用的方法。其中在SMP系統上，LOCK定義成”lock;”表示鎖總線，這樣同一時刻只能有一個CPU訪問總線。非SMP系統，LOCK定義成空。由于InterlockedIncrement要返回遞增前的舊值，所以我們使用了xaddl指令，它先交換源和目的的操作數，再進行遞增操作。 */ INT32i = 1; __asm____volatile__( LOCK"xaddl %0, %1" :"+r"(i), "+m" (*lpAddend) :: "memory"); return*lpAddend; } ~~~ Android提供了相關的原子操作函數。這里，有必要介紹一下各個函數的作用。 **Atomic.h**，注意該文件位置在system/core/include/cutils目錄中。 ~~~ //原子賦值操作，結果是*addr=value void android_atomic_write(int32_t value,volatile int32_t* addr); //下面所有函數的返回值都是操作前的舊值 //原子加1和原子減1 int32_t android_atomic_inc(volatile int32_t*addr); int32_t android_atomic_dec(volatile int32_t*addr); //原子加法操作，value為被加數 int32_t android_atomic_add(int32_t value,volatile int32_t* addr); //原子“與”和“或”操作 int32_t android_atomic_and(int32_t value,volatile int32_t* addr); int32_t android_atomic_or(int32_t value,volatile int32_t* addr); /* 條件交換的原子操作。只有在oldValue等于*addr時，才會把newValue賦值給*addr 這個函數的返回值須特別注意。返回值非零，表示沒有進行賦值操作。返回值為零，表示進行了原子操作。 */ int android_atomic_cmpxchg(int32_t oldvalue,int32_t newvalue,volatile int32_t*addr); ~~~ 有興趣的話，讀者可以對上述函數的實現進行深入研究，其中， - X86平臺的實現在system/core/libcutils/Atomic.c中，注意其代碼在#elif defined(__i386__) || defined(__x86_64__)所包括的代碼段內。 - ARM平臺的實現在system/core/libcutils/atomic-android-arm.S匯編文件中。原子操作的最大好處在于避免了鎖的使用，這對整個程序運行效率的提高有很大幫助。目前，在多核并行編程中，最高境界就是完全不使用鎖。當然，它的難度可想而知是巨大的。