5.3.2　常用同步类

同步，是多线程编程中不可回避的话题，同时也是一个非常复杂的问题。这里只简单介绍一下Android提供的同步类。这些类，只对系统提供的多线程同步函数（这种函数我们称为Raw API）进行了面向对象的封装，读者必须先理解Raw API，然后才能真正掌握其具体用法。

提示　要了解Windows下的多线程编程，有很多参考资料，而有关Linux下完整系统阐述多线程编程的书籍目前较少，这里推荐一本含金量较高的著作《Programming with POSIX Thread》（本书只有英文版，由Addison-Wesley出版）。

Android提供了两个封装好的同步类，它们是Mutex和Condition。这是重量级的同步技术，一般内核都会有对应的支持。另外，OS还提供了简单的原子操作，这些也算是同步技术中的一种。下面分别来介绍这三种东西。

1.互斥类——Mutex

Mutex是互斥类，用于多线程访问同一个资源的时候，保证一次只有一个线程能访问该资源。在《Windows核心编程》^[1]一书中，对于这种互斥访问有一个很形象的比喻：想象你在飞机上如厕，这时卫生间的信息牌上显示“有人”，你必须等里面的人出来后才可进去。这就是互斥的含义。

下面来看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声明和实现]

class Autolock{

public：

//构造的时候调用lock。

inline Autolock（Mutex&mutex）：mLock（mutex）{mLock.lock（）；}

inline Autolock（Mutexmutex）：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只有一个会被唤醒。

void signal（）；

//触发者A用来通知条件已经满足，所有等待者都会被唤醒。

void broadcast（）；

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_t Condition：waitRelative（Mutex&mutex,nsecs_t reltime）{

if defined（HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE）

struct timespec 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也就会被自动调用。

return mStatus；

}

那么，什么时候会触发这个条件呢？是在工作线程退出前。其代码如下所示：

[—＞Thread.cpp]

int Thread：_threadLoop（void*user）

{

Threadconst 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）；

return 0；

}

关于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指令，它先交换源和目的的操作数，再进行递增操作。

*/

INT32 i=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汇编文件中。

原子操作的最大好处在于避免了锁的使用，这对整个程序运行效率的提高有很大帮助。目前，在多核并行编程中，最高境界就是完全不使用锁。当然，它的难度可想而知是巨大的。

[1]本书中文版由机械工业出版社出版，原书作者Jeffrey Richter。