同步，是多线程编程中不可回避的话题，同时也是一个非常复杂的问题。这里，只简单介绍一下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汇编文件中。 原子操作的最大好处在于避免了锁的使用，这对整个程序运行效率的提高有很大帮助。目前，在多核并行编程中，最高境界就是完全不使用锁。当然，它的难度可想而知是巨大的。