🔥码云GVP开源项目 12k star Uniapp+ElementUI 功能强大 支持多语言、二开方便! 广告
同步,是多线程编程中不可回避的话题,同时也是一个非常复杂的问题。这里,只简单介绍一下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汇编文件中。 原子操作的最大好处在于避免了锁的使用,这对整个程序运行效率的提高有很大帮助。目前,在多核并行编程中,最高境界就是完全不使用锁。当然,它的难度可想而知是巨大的。