Android源码之Handler(三)
publicHandler(Looperlooper,Callbackcallback,booleanasync){
mLooper=looper;
mQueue=looper.mQueue;
[//mQueue=looper.mQueue
这里可以看出，Handler类的MessageQueue成员变量mQueue其实就是Looper内部的MessageQueue变量。
]//mQueue=looper.mQueue
mCallback=callback;
mAsynchronous=async;
}
[//publicHandler(Looperlooper,Callbackcallback,booleanasync)
这个重载版本的构造函数的实现就是初始化Handler的几个成员变量。这几个成员变量的定义如下：
finalMessageQueuemQueue;
finalLoopermLooper;
finalCallbackmCallback;
[//finalCallbackmCallback
mCallback是Handler的Callback.其实Message中会有一个Runnable类型的成员变量callback，这里为什么又要给Handler来定义一个Callback的成员变量呢？
Callback接口定义在Handler内部：
publicinterfaceCallback{
publicbooleanhandleMessage(Messagemsg);
}
]//finalCallbackmCallback
finalbooleanmAsynchronous;
[//finalbooleanmAsynchronous
mAsynchronous表示Hanlder是否是异步的?在我们的认识中,Handler就是按照顺序来处理消息的,这难道不是Handler的作用么?难道还可以异步的处理消息么？
]//finalbooleanmAsynchronous
由此可见，每一个Handler内部维护了一个Looper，而每一个Looper中又维护了一个MessageQueue.
这里我们就来看一下Looper的实现:
]//publicHandler(Looperlooper,Callbackcallback,booleanasync)
Handler的一系列的构造函数中，其实最重要的就是两个:Handler(Callbackcallback,booleanasync)和Handler(Looperlooper,Callbackcallback,booleanasync).
]//Handler的构造函数
当通过Handler构造函数得到了Handler对象之后,会调用obtainMessage来得到一个Message对象.Android推介使用Handler的obtainMessage函数来得到一个Message对象，而不是直接构造一个Message对象,为什么呢?
同样Handler类也提供了一系列的obtainMessage函数,我们看一看obtainMessage函数的实现：
[//obtainMessage函数
publicfinalMessageobtainMessage()
{
returnMessage.obtain(this);
}
publicfinalMessageobtainMessage(intwhat)
{
returnMessage.obtain(this,what);
}
publicfinalMessageobtainMessage(intwhat,Objectobj)
{
returnMessage.obtain(this,what,obj);
}
publicfinalMessageobtainMessage(intwhat,intarg1,intarg2)
{
returnMessage.obtain(this,what,arg1,arg2);
}
publicfinalMessageobtainMessage(intwhat,intarg1,intarg2,Objectobj)
{
returnMessage.obtain(this,what,arg1,arg2,obj);
}
从以上代码也可以看出,Handler的obtainMessage函数其实是调用Message的obtain函数来实现的.我们看一下Message类的obtain函数的实现：
[//Message类的obtain函数
publicstaticMessageobtain(Handlerh){
Messagem=obtain();
m.target=h;
returnm;
}
publicstaticMessageobtain(Handlerh,Runnablecallback){
Messagem=obtain();
m.target=h;
m.callback=callback;
returnm;
}
publicstaticMessageobtain(Handlerh,intwhat){
Messagem=obtain();
m.target=h;
m.what=what;
returnm;
}
publicstaticMessageobtain(Handlerh,intwhat,Objectobj){
Messagem=obtain();
m.target=h;
m.what=what;
m.obj=obj;
returnm;
}
publicstaticMessageobtain(Handlerh,intwhat,intarg1,intarg2){
Messagem=obtain();
m.target=h;
m.what=what;
m.arg1=arg1;
m.arg2=arg2;
returnm;
}
publicstaticMessageobtain(Handlerh,intwhat,
intarg1,intarg2,Objectobj){
Messagem=obtain();
m.target=h;
m.what=what;
m.arg1=arg1;
m.arg2=arg2;
m.obj=obj;
returnm;
}
Message类同样提供了一系列的obtain的重载函数,不过大同小异,都是先调用obtain()函数得到一个Message对象,然后初始化这个Message对象，并返回该Message对象。
我们分析一下Message类的obtain函数的实现：
publicstaticMessageobtain(){
synchronized(sPoolSync){
if(sPool!=null){
Messagem=sPool;
sPool=m.next;
m.next=null;
m.flags=0;//clearin-useflag
sPoolSize--;
returnm;
}
}
[//synchronized(sPoolSync)
上面这段代码就是从缓存中取Message。
其中定义了几个成员变量，分别为:
privatestaticfinalObjectsPoolSync=newObject();
privatestaticMessagesPool;
privatestaticintsPoolSize=0;
这些变量的作用都很明确.注意:这些成员变量都是statics的。
]//synchronized(sPoolSync)
returnnewMessage();
}
[//publicstaticMessageobtain()
Message的obtain函数的作用得到一个Message变量.其实Android为Handler维护了一个Message的缓存,调用obtain函数会首先尝试从缓存中取Message对象,而不是每次就构造一个Message对象。
这就是为什么推荐使用obtain函数来得到一个Message对象的原因。
我们简单来看一下Message的几个重要的成员变量:
publicintwhat;
what成员变量是为了区分不同的Message.
publicintarg1;
publicintarg2;
publicObjectobj;
publicMessengerreplyTo;
publicintsendingUid=-1;
/*package*/staticfinalintFLAG_IN_USE=1<<0;
/*package*/staticfinalintFLAG_ASYNCHRONOUS=1<<1;
/*package*/staticfinalintFLAGS_TO_CLEAR_ON_COPY_FROM=FLAG_IN_USE;
/*package*/intflags;
/*package*/longwhen;
when指示该消息需要被处理的时间戳
/*package*/Bundledata;
/*package*/Handlertarget;
target是最重要的成员变量.Android系统就是通过target找到这个Message所属于的Handler对象，然会调用这个Handler对象的handleMessage函数来处理该消息的
/*package*/Runnablecallback;
/*package*/Messagenext;
privatestaticfinalObjectsPoolSync=newObject();
privatestaticMessagesPool;
privatestaticintsPoolSize=0;
privatestaticfinalintMAX_POOL_SIZE=50;
privatestaticbooleangCheckRecycle=true;
]//publicstaticMessageobtain()
]//Message类的obtain函数
]//obtainMessage函数
经过上面的源码分析，我们可以明白Handler,Looper,MessageQueue和Message个关系了，也理解了这四者是如何配合从而完成Handler机制的。
下面我们分析一下发消息的过程，这主要是通过调用Handler的sendMessage和post函数完成的.Handler提供了一系列的send和post函数：
publicfinalbooleanpost(Runnabler)
{
returnsendMessageDelayed(getPostMessage(r),0);
[//sendMessageDelayed(getPostMessage(r),0)
privatestaticMessagegetPostMessage(Runnabler){
Messagem=Message.obtain();
m.callback=r;
returnm;
}
]//sendMessageDelayed(getPostMessage(r),0)
}
publicfinalbooleanpostAtTime(Runnabler,longuptimeMillis)
{
returnsendMessageAtTime(getPostMessage(r),uptimeMillis);
}
publicfinalbooleanpostAtTime(Runnabler,Objecttoken,longuptimeMillis)
{
returnsendMessageAtTime(getPostMessage(r,token),uptimeMillis);
[//returnsendMessageAtTime(getPostMessage(r,token),uptimeMillis)
privatestaticMessagegetPostMessage(Runnabler,Objecttoken){
Messagem=Message.obtain();
m.obj=token;
m.callback=r;
returnm;
}
]//returnsendMessageAtTime(getPostMessage(r,token),uptimeMillis)
}
publicfinalbooleanpostDelayed(Runnabler,longdelayMillis)
{
returnsendMessageDelayed(getPostMessage(r),delayMillis);
}
publicfinalbooleanpostAtFrontOfQueue(Runnabler)
{
returnsendMessageAtFrontOfQueue(getPostMessage(r));
}
publicfinalbooleansendEmptyMessage(intwhat)
{
returnsendEmptyMessageDelayed(what,0);
}
publicfinalbooleansendEmptyMessageDelayed(intwhat,longdelayMillis){
Messagemsg=Message.obtain();
msg.what=what;
returnsendMessageDelayed(msg,delayMillis);
}
publicfinalbooleansendEmptyMessageAtTime(intwhat,longuptimeMillis){
Messagemsg=Message.obtain();
msg.what=what;
returnsendMessageAtTime(msg,uptimeMillis);
}
publicfinalbooleansendMessageDelayed(Messagemsg,longdelayMillis)
{
if(delayMillis<0){
delayMillis=0;
}
returnsendMessageAtTime(msg,SystemClock.uptimeMillis()+delayMillis);
}
publicfinalbooleansendMessageAtFrontOfQueue(Messagemsg){
MessageQueuequeue=mQueue;
if(queue==null){
RuntimeExceptione=newRuntimeException(
this+"sendMessageAtTime()calledwithnomQueue");
Log.w("Looper",e.getMessage(),e);
returnfalse;
}
returnenqueueMessage(queue,msg,0);
}
publicbooleansendMessageAtTime(Messagemsg,longuptimeMillis){
MessageQueuequeue=mQueue;
if(queue==null){
RuntimeExceptione=newRuntimeException(
this+"sendMessageAtTime()calledwithnomQueue");
Log.w("Looper",e.getMessage(),e);
returnfalse;
}
returnenqueueMessage(queue,msg,uptimeMillis);
}
上面这么多的函数(post用于发送Runnable,send用于发送Message)，其实都是很相似的。大致过程都成先得到一个Message,然后调用enqueueMessage函数插入到消息队列中。
我们分析一下enqueueMessage函数的实现：
privatebooleanenqueueMessage(MessageQueuequeue,Messagemsg,longuptimeMillis){
msg.target=this;
if(mAsynchronous){
msg.setAsynchronous(true);
}
returnqueue.enqueueMessage(msg,uptimeMillis);
[//returnqueue.enqueueMessage(msg,uptimeMillis);
这里会调用MessageQueue的enqueueMessage函数来将Message插入到队列中，MessageQueue的enqueueMessage函数的实现如下：
booleanenqueueMessage(Messagemsg,longwhen){
if(msg.target==null){
thrownewIllegalArgumentException("Messagemusthaveatarget.");
}
if(msg.isInUse()){
thrownewIllegalStateException(msg+"Thismessageisalreadyinuse.");
}
synchronized(this){
if(mQuitting){
IllegalStateExceptione=newIllegalStateException(
msg.target+"sendingmessagetoaHandleronadeadthread");
Log.w("MessageQueue",e.getMessage(),e);
msg.recycle();
returnfalse;
}
msg.markInUse();
[//msg.markInUse()
将消息标记为正在使用
voidmarkInUse(){
flags|=FLAG_IN_USE;
}
]//msg.markInUse()
msg.when=when;
Messagep=mMessages;
booleanneedWake;
if(p==null||when==0||when<p.when){
[//if(p==null||when==0||when<p.when)
将消息插入到头部，这时候要唤醒Looper
]//if(p==null||when==0||when<p.when)
msg.next=p;
mMessages=msg;
needWake=mBlocked;
}else{
[//else
将消息插入到队列的中间
]//else
needWake=mBlocked&&p.target==null&&msg.isAsynchronous();
Messageprev;
for(;;){
prev=p;
p=p.next;
if(p==null||when<p.when){
break;
}
if(needWake&&p.isAsynchronous()){
needWake=false;
}
}
msg.next=p;//invariant:p==prev.next
prev.next=msg;
}
//WecanassumemPtr!=0becausemQuittingisfalse.
if(needWake){
nativeWake(mPtr);
[//nativeWake(mPtr)
这里调用nativeWake函数来唤醒Looper,这也是个native函数，实际上调用的是android_os_MessageQueue.cpp中定义的android_os_MessageQueue_nativeWake函数。
android_os_MessageQueue_nativeWake的定义如下：
staticvoidandroid_os_MessageQueue_nativeWake(JNIEnv*env,jclassclazz,jlongptr){
NativeMessageQueue*nativeMessageQueue=reinterpret_cast<NativeMessageQueue*>(ptr);
returnnativeMessageQueue->wake();
[//returnnativeMessageQueue->wake()
这里调用的是NativeMessageQueue的wake函数.
voidNativeMessageQueue::wake(){
mLooper->wake();
[//mLooper->wake()
这里又调用了C++层的wake函数，
voidLooper::wake(){
#ifDEBUG_POLL_AND_WAKE
ALOGD("%p~wake",this);
#endif
ssize_tnWrite;
do{
nWrite=write(mWakeWritePipeFd,"W",1);
}while(nWrite==-1&&errno==EINTR);
if(nWrite!=1){
if(errno!=EAGAIN){
ALOGW("Couldnotwritewakesignal,errno=%d",errno);
}
}
}
可以看到C++层的wake函数就是用mWakeWritePipeFd向管道里发送一个"w"字符，这样就会将epoll_wait函数来唤醒。
]//mLooper->wake()
}
]//returnnativeMessageQueue->wake()
}
]//nativeWake(mPtr)
}
}
returntrue;
}
]//returnqueue.enqueueMessage(msg,uptimeMillis);
}