Android中同步类Mutex（AutoMutex）与Condition。
在Android中，封装的同步类主要有Mutex（AutoMutex）与Condition。
这两个类在android中被大量的使用，这也说明这两个类是非常重要的。
下面我们就从3个方面来分析他们。
-
它们是什么，他们的实现原理，即what
-
为什么要这么去实现它，即why
-
我们怎么去用他们，即how
这样我们就对它们有个深入的理解，不但知其然，而且知其所以然。
一 Mutex（AutoMutex）与Condition代码分析
-
-
Mutex（AutoMutex）代码分析
Mutex是互斥类，用于多线程访问同一个资源的时候，保证一次只有一个线程能访问该资源。在《Windows核心编程》一书中，对于这种互斥访问有一个很形象的比喻：想象你在飞机上如厕，这时卫生间的信息牌上显示“有人”，你必须等里面的人出来后才可进去。这就是互斥的含义。
它的代码实现如下
system/core/include/utils/Mutex.h
/*
* Copyright (C) 2007 The Android Open SourceProject
*
* Licensed under the Apache License, Version2.0 (the "License");
* you may not use this file except incompliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreedto in writing, software
* distributed under the License is distributedon an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANYKIND, either express or implied.
* See the License for the specific languagegoverning permissions and
* limitations under the License.
*/
#ifndef_LIBS_UTILS_MUTEX_H
#define_LIBS_UTILS_MUTEX_H
//ifndef/define/endif 主要目的是防止头文件的重复包含和编译
//如果有两个地方都包含这个头文件，就不会出现两次包含的情况，良好的编程习惯。
#include
// 引用标准库的头文件#include
#include
#ifdefined(HAVE_PTHREADS)
# include
#endif
#include
//---------------------------------------------------------------------------
namespaceandroid { //android的命名空间，使用的时候用“using namespace android;”
//跟C++里的“using namespace std;”一样。
//---------------------------------------------------------------------------
class Condition;
/*
* Simple mutex class. The implementation is system-dependent.
*
* The mutex must be unlocked by the threadthat locked it. They are not
* recursive, i.e. the same thread can't lockit multiple times.
*/
class Mutex {
public:
enum {
PRIVATE = 0,
SHARED = 1
};
//两种类型：PRIVATE是进程内部使用的；SHARED是适用于跨进程共享的。
//如不指定，缺省是PRIVATE的类型。
Mutex(); //构造函数
Mutex(const char* name); //构造函数
Mutex(int type, const char*name = NULL); //构造函数,type就是上面的那两种类型
~Mutex(); //析构
// lock or unlock the mutex
status_t lock(); //获取锁。如果获取就返回，否则挂起等待
void unlock(); //释放锁
// lock if possible; returns 0 on success,error otherwise
status_t tryLock();
//如果当前锁可被获取（未被别的线程获取）就lock，否则就直接返回。
//返回值：0代表成功；其它值失败。
//与lock()的区别在于不论成功与否都会及时返回，而不是挂起等待。
// Manages the mutex automatically. It'llbe locked when Autolock is
// constructed and released when Autolockgoes out of scope.
//Autolock是为了简化Mutex的使用而定义的,并且充分利用了c++的构造与析构机制
//可以看出，在构造函数中 mLock.lock() 加锁，在析构函数中 mLock.unlock() 解锁。
//所以，对一个需要加锁的函数来说，我们只需要在函数开始处，声明这样 (Mutex::Autolock autolock(mLock);)，一个变量，它就会加锁，
//等函数退出时，这样一个临时变量就会析构，就会解锁。
////android系统里几乎到处都是这种使用，或者AutoMutex _l(mLock)这种使用
//这两种使用是一样的效果的，因为下面有这样一行代码typedefMutex::Autolock AutoMutex;
//这种设计师非常优秀的，如果你手动去lock，unlock，就有可能
//忘了unlock,这样的会很容易死锁，死锁在android系统里后果是非常严重，大多数情况都会系统重启
//大家都知道C++的构造函数析构函数是成对出现的，用了构造函数中 mLock.lock() 加锁，
//在析构函数中 mLock.unlock() 解锁这种设计之后，就不会出现忘了unlock的情况了
class Autolock {
public:
inline Autolock(Mutex& mutex) :mLock(mutex) { mLock.lock(); }
//其实这里不加inline也是没有关系的，在C++里编译器会自动去检查这个函数体
//如果函数体逻辑足够简单，会自动把他当成inline函数，为了养成良好的代码习惯，还是要加上
inline Autolock(Mutex* mutex) :mLock(*mutex) { mLock.lock(); }
inline ~Autolock() { mLock.unlock(); }
private:
Mutex& mLock;
};
private:
friend class Condition; //友元类Condition
// A mutex cannot be copied
Mutex(const Mutex&);
Mutex& operator = (const Mutex&);
#ifdefined(HAVE_PTHREADS)
pthread_mutex_t mMutex;
#else
void _init();
void* mState;
#endif
};
//---------------------------------------------------------------------------
#if defined(HAVE_PTHREADS)
inlineMutex::Mutex() {
pthread_mutex_init(&mMutex, NULL);
}
inlineMutex::Mutex(__attribute__((unused)) const char* name) {
pthread_mutex_init(&mMutex, NULL);
}
inlineMutex::Mutex(int type, __attribute__((unused)) const char* name) {
if (type == SHARED) {
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);
}
}
inlineMutex::~Mutex() {
pthread_mutex_destroy(&mMutex);
}
inlinestatus_t Mutex::lock() {
return -pthread_mutex_lock(&mMutex);
}
inline voidMutex::unlock() {
pthread_mutex_unlock(&mMutex);
}
inlinestatus_t Mutex::tryLock() {
return -pthread_mutex_trylock(&mMutex);
}
#endif //HAVE_PTHREADS
//---------------------------------------------------------------------------
/*
* Automatic mutex. Declare one of these at the top of afunction.
* When the function returns, it will go out ofscope, and release the
* mutex.
*/
typedefMutex::Autolock AutoMutex;
//---------------------------------------------------------------------------
}; //namespace android
// ---------------------------------------------------------------------------
#endif //_LIBS_UTILS_MUTEX_H
1.2 Condition代码分析
Condition条件类，在多线程同步中，主要是下面这种使用场景使用到condition。
线程A做初始化工作，而其他线程，比如线程B、C必须等到A初始化工作完后才能工作，即线程B、C在等待一个条件，我们称B、C为等待者。
当线程A完成初始化工作时，会触发这个条件，那么等待者B、C就会被唤醒。触发这个条件的A就是触发者。
上面的使用场景非常形象，而且条件类提供的函数也非常形象，它的代码如下所示：system/core/include/utils/Condition.h
/*
* Copyright (C) 2007 The Android Open SourceProject
*
* Licensed under the Apache License, Version2.0 (the "License");
* you may not use this file except incompliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreedto in writing, software
* distributed under the License is distributedon an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANYKIND, either express or implied.
* See the License for the specific languagegoverning permissions and
* limitations under the License.
*/
#ifndef_LIBS_UTILS_CONDITION_H
#define_LIBS_UTILS_CONDITION_H
#include
#include
#include
#if defined(HAVE_PTHREADS)
# include
#endif
#include
#include
#include
//---------------------------------------------------------------------------
namespace android {
//---------------------------------------------------------------------------
/*
* Condition variable class. The implementation is system-dependent.
*
* Condition variables are paired up withmutexes. Lock the mutex,
* call wait(), then either re-wait() if thingsaren't quite what you want,
* or unlock the mutex and continue. All threads calling wait() must
* use the same mutex for a given Condition.
*/
class Condition {
public:
enum {
PRIVATE = 0,
SHARED = 1
};
//两种类型：PRIVATE是进程内部使用的；SHARED是适用于跨进程共享的。
//如不指定，缺省是PRIVATE的类型。
enum WakeUpType {
WAKE_UP_ONE = 0,
WAKE_UP_ALL = 1
};
Condition(); ////构造函数
Condition(int type);//构造函数,type就是上面的那两种类型
~Condition();//析构
// Wait on the condition variable. Lock the mutex before calling.
//线程B和C等待事件，wait这个名字也很形象
status_t wait(Mutex& mutex);
// same with relative timeout
//线程B和C的超时等待，B和C可以指定等待时间，当超过这个时间，条件却还不满足，则退出等待。
status_t waitRelative(Mutex& mutex,nsecs_t reltime);
// Signal the condition variable, allowingexactly one thread to continue.
//触发者A用来通知条件已经满足，但是B和C只有一个会被唤醒
void signal();
// Signal the condition variable, allowingone or all threads to continue.
void signal(WakeUpType type) {
if (type == WAKE_UP_ONE) {
signal();
} else {
broadcast();
}
}
// Signal the condition variable, allowingall threads to continue.
//触发者A用来通知条件已经满足，所有等待者都会被唤醒。
void broadcast();
private:
#ifdefined(HAVE_PTHREADS)
pthread_cond_t mCond;
#else
void* mState;
#endif
};
//---------------------------------------------------------------------------
#ifdefined(HAVE_PTHREADS)
inlineCondition::Condition() {
pthread_cond_init(&mCond, NULL);
}
inlineCondition::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);
}
}
inlineCondition::~Condition() {
pthread_cond_destroy(&mCond);
}
inline status_tCondition::wait(Mutex& mutex) {
return -pthread_cond_wait(&mCond,&mutex.mMutex);
}
inline status_tCondition::waitRelative(Mutex& mutex, nsecs_t reltime) {
#ifdefined(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);
#else //HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE
struct timespec ts;
#ifdefined(HAVE_POSIX_CLOCKS)
clock_gettime(CLOCK_REALTIME, &ts);
#else //HAVE_POSIX_CLOCKS
// we don't support the clocks here.
struct timeval t;
gettimeofday(&t, NULL);
ts.tv_sec = t.tv_sec;
ts.tv_nsec= t.tv_usec*1000;
#endif //HAVE_POSIX_CLOCKS
ts.tv_sec += reltime/1000000000;
ts.tv_nsec+= reltime%1000000000;
if (ts.tv_nsec >= 1000000000) {
ts.tv_nsec -= 1000000000;
ts.tv_sec += 1;
}
return -pthread_cond_timedwait(&mCond,&mutex.mMutex, &ts);
#endif //HAVE_PTHREAD_COND_TIMEDWAIT_RELATIVE
}
//inline函数
//signal()和broadcast()的实现是凭借调用了Raw API的pthread_cond_signal(&mCond)与pthread_cond_broadcast(&mCond)
//这里要重点说明的是，Condition类必须配合Mutex来使用。
// 在上面的代码中，不论是wait、waitRelative、signal还是broadcast的调用，都放在一个Mutex的lock和unlock范围中，尤其是wait和waitRelative函数的调用，这是强制性的。
inline voidCondition::signal() {
/*
* POSIX says pthread_cond_signal wakes up"one or more" waiting threads.
*However bionic follows the glibc guarantee which wakes up "exactlyone"
* waiting thread.
*
* man 3 pthread_cond_signal
* pthread_cond_signal restarts one of the threads that are waiting on
* the condition variable cond. If no threads are waiting on cond,
* nothing happens. If several threads are waiting on cond, exactly one
* is restarted, but it is not specified which.
*/
pthread_cond_signal(&mCond);
}
inline voidCondition::broadcast() {
pthread_cond_broadcast(&mCond);
}
#endif //HAVE_PTHREADS
//---------------------------------------------------------------------------
}; // namespaceandroid
//---------------------------------------------------------------------------
#endif // _LIBS_UTILS_CONDITON_H
二、为什么android要封装AutoMutex
在android系统中，死锁是非常严重的，基本都是会引起系统死机，crash，重启的，并且死锁在android系统开发中，也是会经常碰见的。所以我们要尽量避免死锁，android就给我们封装了AutoMutex。它充分利用了c++的构造与析构机制，在构造函数中 mLock.lock() 加锁，在析构函数中 mLock.unlock() 解锁。
对一个需要加锁的函数来说，我们只需要在函数开始处，AutoMutex _l(mLock)就完成了加锁，等函数退出时，这样一个临时变量就会析构，就会解锁。
三、Autolock/AutoMutex与Condition的使用
-
-
-
Autolock/AutoMutex的使用
用法比较简单，定义一个局部临时的AutoMutex变量，在该变量定义的地方，构造函数被自动调用，会执行Mutex的lock()操作；在该变量作用域结束的地方，析构函数会被自动调用，会执行Mutex的unlock操作。
所以，你只需要在Mutex保护的区域开始的地方定义一个AutoMutex变量即可，即可实现用Mutex对该区域的保护。 -
Condition的使用
我们看一个android原生的类是怎么使用condition和Mutex的。
这个例子是Thread类的requestExitAndWait，目的是等待工作线程退出，代码如下所示：
system/core/libutils/Threads.cpp
status_t Thread::requestExitAndWait(){
Mutex::Autolock _l(mLock);
if (mThread == getThreadId()) {
ALOGW(
"Thread (this=%p): don't callwaitForExit() from this "
"Thread object's thread. It's aguaranteed deadlock!",
this);
return WOULD_BLOCK;
}
mExitPending = true;
while (mRunning == true) {
mThreadExitedCondition.wait(mLock);//这里wait
}
// This next line is probably not neededany more, but is being left for
// historical reference. Note that eachinterested party will clear flag.
mExitPending = false;
return mStatus;
}
那么，什么时候会触发这个条件呢？是在工作线程退出前。其代码如下所示：
int Thread::_threadLoop(void* user){
Thread* const self =static_cast
sp
strong(self->mHoldSelf); wp
weak(strong); self->mHoldSelf.clear();
#ifdef HAVE_ANDROID_OS
// this is very useful for debugging withgdb
self->mTid = gettid();
#endif
bool first = true;
do {
bool result;
if (first) {
first = false;
self->mStatus =self->readyToRun();
result = (self->mStatus ==NO_ERROR);
if (result &&!self->exitPending()) {
// Binder threads (and maybeothers) rely on threadLoop
// running at least once aftera successful ::readyToRun()
// (unless, of course, thethread has already been asked to exit
// at that point).
// This is because threads areessentially used like this:
// (new ThreadSubclass())->run();
// The caller therefore doesnot retain a strong reference to
// the thread and the thread wouldsimply disappear after the
// successful ::readyToRun()call instead of entering the
// threadLoop at least once.
result = self->threadLoop();
}
} else {
result = self->threadLoop();
}
// establish a scope for mLock
{
Mutex::Autolock _l(self->mLock);
if (result == false ||self->mExitPending) {
self->mExitPending = true;
self->mRunning = false;
// clear thread ID so thatrequestExitAndWait() does not exit if
// called by a new thread using thesame thread ID as this one.
self->mThread = thread_id_t(-1);
// note that interested observersblocked in requestExitAndWait are
// awoken by broadcast, but blockedon mLock until break exits scope
self->mThreadExitedCondition.broadcast(); //这里broadcast
break;
}
}
// Release our strong reference, to leta chance to the thread
// to die a peaceful death.
strong.clear();
// And immediately, re-acquire a strongreference for the next loop
strong = weak.promote();
} while(strong != 0);
return 0;
}
通过以上的学习，我们对Autolock/AutoMutex与Condition就有个深入的理解，
在以后android系统看到它们就知道他们的作用，已经怎么样去使用它了，达到写的代码更少的bug。
-