Android消息机制源码解析（一）——消息的载体Message

说到Android的消息机制，大家再熟悉不过了，几乎每个逻辑界面中都会涉及到，Activity的生命周期回调也是通过系统消息机制完成的，可见消息机制在Android中的重要性。在应用层，一般我们都是使用Handler来发送、处理消息，从工作线程切换到主线程来更新UI。往往开发者只跟Handler、Message打交道就能满足需求了，但它们背后的实现原理是怎样的呢？为了加深理解，深入学习Android设计理念，同时也希望给初学者带来一些帮助，下面会从源码角度来分析Android的消息机制，鉴于篇幅原因，大致分为如下四个小节：

1.Andorid消息的载体Message

2.Android消息的执行者Handler

3.Android消息的循环器Looper

4.Android消息队列MessageQueue

直入正题，先来看Android消息的载体——Message。

一、大家都知道Handler发送的是消息，这里的消息对应的正是Message对象，来看一下源码中Message的定义与实现。

publicfinalclassMessageimplementsParcelable

首先可以看到Message实现了Parcelable接口，那么接下来就必然会实现序列化需要的几个方法，序列化部分代码不需要过多解释，具体如下：

publicstaticfinalParcelable.Creator<Message>CREATOR
=newParcelable.Creator<Message>(){
publicMessagecreateFromParcel(Parcelsource){
Messagemsg=Message.obtain();
msg.readFromParcel(source);
returnmsg;
}

publicMessage[]newArray(intsize){
returnnewMessage[size];
}
};

publicintdescribeContents(){
return0;
}

publicvoidwriteToParcel(Parceldest,intflags){
if(callback!=null){
thrownewRuntimeException(
"Can'tmarshalcallbacksacrossprocesses.");
}
dest.writeInt(what);
dest.writeInt(arg1);
dest.writeInt(arg2);
if(obj!=null){
try{
Parcelablep=(Parcelable)obj;
dest.writeInt(1);
dest.writeParcelable(p,flags);
}catch(ClassCastExceptione){
thrownewRuntimeException(
"Can'tmarshalnon-Parcelableobjectsacrossprocesses.");
}
}else{
dest.writeInt(0);
}
dest.writeLong(when);
dest.writeBundle(data);
Messenger.writeMessengerOrNullToParcel(replyTo,dest);
dest.writeInt(sendingUid);
}

privatevoidreadFromParcel(Parcelsource){
what=source.readInt();
arg1=source.readInt();
arg2=source.readInt();
if(source.readInt()!=0){
obj=source.readParcelable(getClass().getClassLoader());
}
when=source.readLong();
data=source.readBundle();
replyTo=Messenger.readMessengerOrNullFromParcel(source);
sendingUid=source.readInt();
}
}

二、下面重量级的嘉宾开始登场了，之所以把Message称为消息的载体，是因为Message是对消息内容的一个封装，根据平时的开发经验，大家知道Message可以传递一些数据，比如整型、Bundle以及Object，那么Message为什么拥有这种能力呢？来看下Message的几个重要属性字段：

publicintwhat;

publicintarg1;

publicintarg2;

publicObjectobj;

/*package*/longwhen;
/*package*/Bundledata;
/*package*/Handlertarget;
/*package*/Runnablecallback;

相信大家对前边几个字段非常熟悉，what是开发者自定义的一个整型标识，作用就是接收者（接收者就是Handler了）收到消息时可以知道此消息的来源与用途；有时候一个消息仅需要简单传递一些轻量级的整数，此时arg1和arg2就可以派上用场了，从而不必使用Bundle，可以节省开销；Message还可以利用Object来传递任意数据，但在用于进程间通讯时，如object实现了Parceable则必须保证不为空；当然最常用的是通过Bundle来传递数据了，即上面第6个字段；when用来存储消息何时执行；target实际上是一个Handler,表示该消息是由谁发送的；此外Message还有一个callback字段，本质上是一个Runnable，用来支持发送Runnable类型的消息，如Handler中的方法：

publicfinalbooleanpost(Runnabler)

参数Runnable最终被赋给消息的上述callback字段。

Android中的Message对象是按链表结构存储的，这样就可以利用消息池，从而减少对象的创建，提高性能，具体有如下相关字段：

/*package*/Messagenext;
privatestaticMessagesPool;
privatestaticintsPoolSize=0;
privatestaticfinalintMAX_POOL_SIZE=50;
privatestaticbooleangCheckRecycle=true;

从字段名称很容易理解，sPool可以理解为消息链表的头部，next指向下一条消息，其中默认消息池初始值为0，最大容量为50；gCheckRecycle是一个用来辅助回收消息的辅助变量。

此外，Message还有如下两个字段：

publicMessengerreplyTo;

publicintsendingUid=-1;

这两个字段是用来进程间通讯的，这里就不再展开。

三、Message的主要属性字段都介绍完了，那么如何创建一个Message呢？尽管Message提供了public的无参构造函数，但是并不建议通过构造函数创建Message对象。很多无经验的开发者往往会new一个Message，这是不可取的，应该特别注意。Message类为我们提供了obtain()及多个同名方法来从消息池中获取一个Message，这样就可以利用消息池中回收的对象，避免重新创建对象，以节省开销。来看一下obtain()方法：

publicstaticMessageobtain(){
synchronized(sPoolSync){
if(sPool!=null){
Messagem=sPool;
sPool=m.next;
m.next=null;
m.flags=0;//clearin-useflag
sPoolSize--;
returnm;
}
}
returnnewMessage();
}

代码很简单，sPoolSync是用来保证线程同步的，上述代码仅在消息池中没有可用对象时才通过无参构造方法创建对象，否则就从消息池中返回一个Message对象。obtain()其他同名方法原理也一样，只不过会将参数赋值给获取到的Message各个字段（最初提到的what、arg1、arg2、obj、target等属性字段），如带Handler参数的obtain()方法：

publicstaticMessageobtain(Handlerh){
Messagem=obtain();
m.target=h;

returnm;
}

如带有Handler、what、obj三个参数的obtain()方法：

publicstaticMessageobtain(Handlerh,intwhat,Objectobj){
Messagem=obtain();
m.target=h;
m.what=what;
m.obj=obj;

returnm;
}

其他类似，就不再一一列举。

分析到这里，事先提一下，除了使用Message类的obtain()相关方法获取消息对象之外，也可以使用Handler类提供的obtainMessage()系列方法，其内部实现则是调用了Message的obtain()系列方法，等第二节讲到Handler时会详细说明。

四、Message类提供了几个set方法，如：

publicvoidsetTarget(Handlertarget){
this.target=target;
}

如果obtain()方法中没有传递Handler参数，则可以使用上述方法设置，明确该消息由谁来发送和接收。指定消息的Handler后，还有一个sendToTarget():

/**
*SendsthisMessagetotheHandlerspecifiedby{@link#getTarget}.
*Throwsanullpointerexceptionifthisfieldhasnotbeenset.
*/
publicvoidsendToTarget(){
target.sendMessage(this);
}

注释已经写的很清楚了，如果一个消息未指定Handler，则调用此方法会报空指针。我们在开发时需要发送一个消息，往往会这样写：

Messagemessage=Message.obtain(mHandler,what,obj);

message.sendToTarget();

sendToTarget()实际上会调用Handler中发送消息的方法，最终会将消息添加到一个队列中，当然发送消息也可以直接使用Handler的sendMessage系列方法，这些内容在后面会详细介绍。

如果需要使用Bundle来发送消息，那么当封装好Bundle后，可以利用以下方法将Bundle保存到消息中：

publicvoidsetData(Bundledata){
this.data=data;
}

同样Message类还提供了一系列获取对象属性的方法，如：

publiclonggetWhen(){
returnwhen;
}

上述方法返回消息的执行时间。

publicHandlergetTarget(){
returntarget;
}

上述方法返回发送、接收消息的Handler对象。

publicRunnablegetCallback(){
returncallback;
}

上述方法返回Runnable对象。

publicBundlegetData(){
if(data==null){
data=newBundle();
}

returndata;
}

此方法返回一个Bundle,如果为空则会创建一个新的对象返回。

publicBundlepeekData(){
returndata;
}

此方法则不管Bundle是否为空，直接返回。

五、接下来再看一下消息回收的源码实现：

/**
*RecyclesaMessagethatmaybein-use.
*UsedinternallybytheMessageQueueandLooperwhendisposingofqueuedMessages.
*/
voidrecycleUnchecked(){
//Markthemessageasinusewhileitremainsintherecycledobjectpool.
//Clearoutallotherdetails.
flags=FLAG_IN_USE;
what=0;
arg1=0;
arg2=0;
obj=null;
replyTo=null;
sendingUid=-1;
when=0;
target=null;
callback=null;
data=null;

synchronized(sPoolSync){
if(sPoolSize<MAX_POOL_SIZE){
next=sPool;
sPool=this;
sPoolSize++;
}
}
}

代码比较容易理解，就是消息的各个属性置为初始值，同时消息池数量在未超限时加1。

六、最后简单说一下异步消息，一般情况下发送的消息都是同步的，在某些情况下可能会用到异步消息，比如View的刷新。异步消息顾名思义，它不会受同步消息的顺序限制，因此可能引发不可预知的情况，所以建议慎用。如果需要将某个消息设置为异步执行，可调用如下方法：

publicvoidsetAsynchronous(booleanasync){
if(async){
flags|=FLAG_ASYNCHRONOUS;
}else{
flags&=~FLAG_ASYNCHRONOUS;
}
}

其中flag是一个int型的标识字段，如果想判断某个消息是否为异步消息，调用如下方法：

publicbooleanisAsynchronous(){
return(flags&FLAG_ASYNCHRONOUS)!=0;
}

Message源码比较简单，逻辑也很清楚，总结一下，主要是Message的一些重要的属性字段、Message的链表特性以及如何利用obtain()系列方法高效创建一个Message对象等。Android消息的载体Message我们已经彻底搞清楚了，那么这些构造好的消息又是如何发送出去的呢，它们又是如何被接收和处理的？请看《Android消息机制源码解析（二）——消息的执行者Handler》。

更多相关文章

随机推荐