android中Message机制的灵活应用

关键字: 消息机制 handler looper 线程间通信 message messagequeue

引用来自easyandroid论坛，原文：http://www.easyandroid.com/bbs/viewthread.php?tid=33
1.活用Android线程间通信的Message机制

1.1.Message
代码在frameworks\base\core\java\android\Os\Message.java中。

Message.obtain函数：有多个obtain函数，主要功能一样，只是参数不一样。作用是从Message Pool中取出一个Message，如果Message Pool中已经没有Message可取则新建一个Message返回，同时用对应的参数给得到的Message对象赋值。

Message Pool：大小为10个；通过Message.mPool->（Message并且Message.next）-> （Message并且Message.next）-> （Message并且Message.next）...构造一个Message Pool。Message Pool的第一个元素直接new出来，然后把Message.mPool（static类的static变量）指向它。其他的元素都是使用完的 Message通过Message的recycle函数清理后放到Message Pool（通过Message Pool最后一个Message的next指向需要回收的Message的方式实现）。下图为Message Pool的结构：

1.2.MessageQueue
MessageQueue里面有一个收到的Message的对列：

MessageQueue.mMessages(static变量)->( Message并且Message.next)-> ( Message并且Message.next)->...，下图为接收消息的消息队列：

上层代码通过Handler的sendMessage等函数放入一个message到MessageQueue里面时最终会调用MessageQueue的 enqueueMessage函数。enqueueMessage根据上面的接收的Message的队列的构造把接收到的Message放入队列中。

MessageQueue的removeMessages函数根据上面的接收的Message的队列的构造把接收到的Message从队列中删除，并且调用对应Message对象的recycle函数把不用的Message放入Message Pool中。

1.3.Looper
Looper对象的创建是通过prepare函数，而且每一个Looper对象会和一个线程关联

Java代码

publicstaticfinalvoidprepare(){
if(sThreadLocal.get()!=null){
thrownewRuntimeException("OnlyoneLoopermaybecreatedperthread");
}
sThreadLocal.set(newLooper());
}

public static final void prepare() {    if (sThreadLocal.get() != null) {        throw new RuntimeException("Only one Looper may be created per thread");    }    sThreadLocal.set(new Looper());}

Looper对象创建时会创建一个MessageQueue，主线程默认会创建一个Looper从而有MessageQueue，其他线程默认是没有 MessageQueue的不能接收Message，如果需要接收Message则需要通过prepare函数创建一个MessageQueue。具体操作请见示例代码。

Java代码

privateLooper(){
mQueue=newMessageQueue();
mRun=true;
mThread=Thread.currentThread();
}

private Looper() {    mQueue = new MessageQueue();    mRun = true;    mThread = Thread.currentThread();}

prepareMainLooper函数只给主线程调用（系统处理，程序员不用处理），它会调用prepare建立Looper对象和MessageQueue。

Java代码

publicstaticfinalvoidprepareMainLooper(){
prepare();
setMainLooper(myLooper());
if(Process.supportsProcesses()){
myLooper().mQueue.mQuitAllowed=false;
}
}

public static final void prepareMainLooper() {    prepare();    setMainLooper(myLooper());    if (Process.supportsProcesses()) {        myLooper().mQueue.mQuitAllowed = false;    }}

Loop函数从MessageQueue中从前往后取出Message，然后通过Handler的dispatchMessage函数进行消息的处理（可见消息的处理是Handler负责的），消息处理完了以后通过Message对象的recycle函数放到Message Pool中，以便下次使用，通过Pool的处理提供了一定的内存管理从而加速消息对象的获取。至于需要定时处理的消息如何做到定时处理，请见 MessageQueue的next函数，它在取Message来进行处理时通过判断MessageQueue里面的Message是否符合时间要求来决定是否需要把Message取出来做处理，通过这种方式做到消息的定时处理。

Java代码

publicstaticfinalvoidloop(){
Looperme=myLooper();
MessageQueuequeue=me.mQueue;
while(true){
Messagemsg=queue.next();//mightblock
//if(!me.mRun){
//break;
//}
if(msg!=null){
if(msg.target==null){
//Notargetisamagicidentifierforthequitmessage
return;
}
if(me.mLogging!=null)
me.mLogging.println(">>>>>Dispatchingto"+msg.target+""+msg.callback+":"+msg.what);
msg.target.dispatchMessage(msg);
if(me.mLogging!=null)
me.mLogging.println("<<<<<Finishedto"+msg.target+""+msg.callback);
msg.recycle();
}
}
}

public static final void loop() {    Looper me = myLooper();    MessageQueue queue = me.mQueue;    while (true) {        Message msg = queue.next(); // might block        //if (!me.mRun) {        //    break;        //}        if (msg != null) {            if (msg.target == null) {                // No target is a magic identifier for the quit message                return;            }            if (me.mLogging!= null)                 me.mLogging.println(">>>>> Dispatching to " + msg.target + " "+ msg.callback + ": " + msg.what);            msg.target.dispatchMessage(msg);            if (me.mLogging!= null)                 me.mLogging.println("<<<<< Finished to" + msg.target + " "+ msg.callback);            msg.recycle();        }    }}

1.4.Handler

Handler的构造函数表示Handler会有成员变量指向Looper和MessageQueue，后面我们会看到没什么需要这些引用；至于callback是实现了Callback接口的对象，后面会看到这个对象的作用。

Java代码

publicHandler(Looperlooper,Callbackcallback){
mLooper=looper;
mQueue=looper.mQueue;
mCallback=callback;
}
publicinterfaceCallback{
publicbooleanhandleMessage(Messagemsg);
}

public Handler(Looper looper, Callback callback) {    mLooper = looper;    mQueue = looper.mQueue;    mCallback = callback;}public interface Callback {    public boolean handleMessage(Message msg);}

获取消息：直接通过Message的obtain方法获取一个Message对象。

Java代码

publicfinalMessageobtainMessage(intwhat,intarg1,intarg2,Objectobj){
returnMessage.obtain(this,what,arg1,arg2,obj);
}

public final Message obtainMessage(int what, int arg1, int arg2, Object obj){    return Message.obtain(this, what, arg1, arg2, obj);}

发送消息：通过MessageQueue的enqueueMessage把Message对象放到MessageQueue的接收消息队列中

Java代码

publicbooleansendMessageAtTime(Messagemsg,longuptimeMillis){
booleansent=false;
MessageQueuequeue=mQueue;
if(queue!=null){
msg.target=this;
sent=queue.enqueueMessage(msg,uptimeMillis);
}else{
RuntimeExceptione=newRuntimeException(this+"sendMessageAtTime()calledwithnomQueue");
Log.w("Looper",e.getMessage(),e);
}
returnsent;
}

public boolean sendMessageAtTime(Message msg, long uptimeMillis){    boolean sent = false;    MessageQueue queue = mQueue;    if (queue != null) {        msg.target = this;    sent = queue.enqueueMessage(msg, uptimeMillis);    } else {        RuntimeException e = new RuntimeException(this + " sendMessageAtTime() called with no mQueue");        Log.w("Looper", e.getMessage(), e);    }    return sent;}

线程如何处理MessageQueue中接收的消息：在Looper的loop函数中循环取出MessageQueue的接收消息队列中的消息，然后调用 Hander的dispatchMessage函数对消息进行处理，至于如何处理（相应消息）则由用户指定（三个方法，优先级从高到低：Message里面的Callback，一个实现了Runnable接口的对象，其中run函数做处理工作；Handler里面的mCallback指向的一个实现了 Callback接口的对象，里面的handleMessage进行处理；处理消息Handler对象对应的类继承并实现了其中 handleMessage函数，通过这个实现的handleMessage函数处理消息）。

Java代码

publicvoiddispatchMessage(Messagemsg){
if(msg.callback!=null){
handleCallback(msg);
}else{
if(mCallback!=null){
if(mCallback.handleMessage(msg)){
return;
}
}
handleMessage(msg);
}
}

public void dispatchMessage(Message msg) {    if (msg.callback != null) {        handleCallback(msg);    } else {        if (mCallback != null) {            if (mCallback.handleMessage(msg)) {                return;            }        }        handleMessage(msg);    }}

Runnable说明：Runnable只是一个接口，实现了这个接口的类对应的对象也只是个普通的对象，并不是一个Java中的Thread。Thread类经常使用Runnable，很多人有误解，所以这里澄清一下。

从上可知以下关系图：

其中清理Message是Looper里面的loop函数指把处理过的Message放到Message的Pool里面去，如果里面已经超过最大值10个，则丢弃这个Message对象。

调用Handler是指Looper里面的loop函数从MessageQueue的接收消息队列里面取出消息，然后根据消息指向的Handler对象调用其对应的处理方法。
1.5.代码示例

下面我们会以android实例来展示对应的功能，程序界面于下：

程序代码如下，后面部分有代码说明：

Java代码

packagecom.android.messageexample;
importandroid.app.Activity;
importandroid.content.Context;
importandroid.graphics.Color;
importandroid.os.Bundle;
importandroid.os.Handler;
importandroid.os.Looper;
importandroid.os.Message;
importandroid.util.Log;
importandroid.view.View;
importandroid.view.View.OnClickListener;
importandroid.widget.Button;
importandroid.widget.LinearLayout;
importandroid.widget.TextView;
publicclassMessageExampleextendsActivityimplementsOnClickListener{
privatefinalintWC=LinearLayout.LayoutParams.WRAP_CONTENT;
privatefinalintFP=LinearLayout.LayoutParams.FILL_PARENT;
publicTextViewtv;
privateEventHandlermHandler;
privateHandlermOtherThreadHandler=null;
privateButtonbtn,btn2,btn3,btn4,btn5,btn6;
privateNoLooperThreadnoLooerThread=null;
privateOwnLooperThreadownLooperThread=null;
privateReceiveMessageThreadreceiveMessageThread=null;
privateContextcontext=null;
privatefinalStringsTag="MessageExample";
privatebooleanpostRunnable=false;
/**Calledwhentheactivityisfirstcreated.*/
@Override
publicvoidonCreate(BundlesavedInstanceState){
super.onCreate(savedInstanceState);
context=this.getApplicationContext();
LinearLayoutlayout=newLinearLayout(this);
layout.setOrientation(LinearLayout.VERTICAL);
btn=newButton(this);
btn.setId(101);
btn.setText("messagefrommainthreadself");
btn.setOnClickListener(this);
LinearLayout.LayoutParamsparam=
newLinearLayout.LayoutParams(250,50);
param.topMargin=10;
layout.addView(btn,param);
btn2=newButton(this);
btn2.setId(102);
btn2.setText("messagefromotherthreadtomainthread");
btn2.setOnClickListener(this);
layout.addView(btn2,param);
btn3=newButton(this);
btn3.setId(103);
btn3.setText("messagetootherthreadfromitself");
btn3.setOnClickListener(this);
layout.addView(btn3,param);
btn4=newButton(this);
btn4.setId(104);
btn4.setText("messagewithRunnableascallbackfromotherthreadtomainthread");
btn4.setOnClickListener(this);
layout.addView(btn4,param);
btn5=newButton(this);
btn5.setId(105);
btn5.setText("mainthread'smessagetootherthread");
btn5.setOnClickListener(this);
layout.addView(btn5,param);
btn6=newButton(this);
btn6.setId(106);
btn6.setText("exit");
btn6.setOnClickListener(this);
layout.addView(btn6,param);
tv=newTextView(this);
tv.setTextColor(Color.WHITE);
tv.setText("");
LinearLayout.LayoutParamsparam2=
newLinearLayout.LayoutParams(FP,WC);
param2.topMargin=10;
layout.addView(tv,param2);
setContentView(layout);
//主线程要发送消息给otherthread，这里创建那个otherthread
receiveMessageThread=newReceiveMessageThread();
receiveMessageThread.start();
}
//implementtheOnClickListenerinterface
@Override
publicvoidonClick(Viewv){
switch(v.getId()){
case101:
//主线程发送消息给自己
Looperlooper;
looper=Looper.myLooper();//gettheMainlooperrelatedwiththemainthread
//如果不给任何参数的话会用当前线程对应的Looper(这里就是MainLooper)为Handler里面的成员mLooper赋值
mHandler=newEventHandler(looper);
//mHandler=newEventHandler();
//清除整个MessageQueue里的消息
mHandler.removeMessages(0);
Stringobj="Thismainthread'smessageandreceivedbyitself!";
//得到Message对象
Messagem=mHandler.obtainMessage(1,1,1,obj);
//将Message对象送入到mainthread的MessageQueue里面
mHandler.sendMessage(m);
break;
case102:
//other线程发送消息给主线程
postRunnable=false;
noLooerThread=newNoLooperThread();
noLooerThread.start();
break;
case103:
//otherthread获取它自己发送的消息
tv.setText("pleaselookattheerrorlevellogforotherthreadreceivedmessage");
ownLooperThread=newOwnLooperThread();
ownLooperThread.start();
break;
case104:
//otherthread通过PostRunnable方式发送消息给主线程
postRunnable=true;
noLooerThread=newNoLooperThread();
noLooerThread.start();
break;
case105:
//主线程发送消息给otherthread
if(null!=mOtherThreadHandler){
tv.setText("pleaselookattheerrorlevellogforotherthreadreceivedmessagefrommainthread");
StringmsgObj="messagefrommainThread";
MessagemainThreadMsg=mOtherThreadHandler.obtainMessage(1,1,1,msgObj);
mOtherThreadHandler.sendMessage(mainThreadMsg);
}
break;
case106:
finish();
break;
}
}
classEventHandlerextendsHandler
{
publicEventHandler(Looperlooper){
super(looper);
}
publicEventHandler(){
super();
}
publicvoidhandleMessage(Messagemsg){
//可以根据msg.what执行不同的处理，这里没有这么做
switch(msg.what){
case1:
tv.setText((String)msg.obj);
break;
case2:
tv.setText((String)msg.obj);
noLooerThread.stop();
break;
case3:
//不能在非主线程的线程里面更新UI，所以这里通过Log打印收到的消息
Log.e(sTag,(String)msg.obj);
ownLooperThread.stop();
break;
default:
//不能在非主线程的线程里面更新UI，所以这里通过Log打印收到的消息
Log.e(sTag,(String)msg.obj);
break;
}
}
}
//NoLooperThread
classNoLooperThreadextendsThread{
privateEventHandlermNoLooperThreadHandler;
publicvoidrun(){
LoopermyLooper,mainLooper;
myLooper=Looper.myLooper();
mainLooper=Looper.getMainLooper();//这是一个static函数
Stringobj;
if(myLooper==null){
mNoLooperThreadHandler=newEventHandler(mainLooper);
obj="NoLooperThreadhasnolooperandhandleMessagefunctionexecutedinmainthread!";
}
else{
mNoLooperThreadHandler=newEventHandler(myLooper);
obj="ThisisfromNoLooperThreadselfandhandleMessagefunctionexecutedinNoLooperThread!";
}
mNoLooperThreadHandler.removeMessages(0);
if(false==postRunnable){
//sendmessagetomainthread
Messagem=mNoLooperThreadHandler.obtainMessage(2,1,1,obj);
mNoLooperThreadHandler.sendMessage(m);
Log.e(sTag,"NoLooperThreadid:"+this.getId());
}else{
//下面new出来的实现了Runnable接口的对象中run函数是在MainThread中执行，不是在NoLooperThread中执行
//注意Runnable是一个接口，它里面的run函数被执行时不会再新建一个线程
//您可以在run上加断点然后在eclipse调试中看它在哪个线程中执行
mNoLooperThreadHandler.post(newRunnable(){
@Override
publicvoidrun(){
tv.setText("updateUIthroughhandlerpostrunnalbemechanism!");
noLooerThread.stop();
}
});
}
}
}
//OwnLooperThreadhashisownmessagequeuebyexecuteLooper.prepare();
classOwnLooperThreadextendsThread{
privateEventHandlermOwnLooperThreadHandler;
publicvoidrun(){
Looper.prepare();
LoopermyLooper,mainLooper;
myLooper=Looper.myLooper();
mainLooper=Looper.getMainLooper();//这是一个static函数
Stringobj;
if(myLooper==null){
mOwnLooperThreadHandler=newEventHandler(mainLooper);
obj="OwnLooperThreadhasnolooperandhandleMessagefunctionexecutedinmainthread!";
}
else{
mOwnLooperThreadHandler=newEventHandler(myLooper);
obj="ThisisfromOwnLooperThreadselfandhandleMessagefunctionexecutedinNoLooperThread!";
}
mOwnLooperThreadHandler.removeMessages(0);
//给自己发送消息
Messagem=mOwnLooperThreadHandler.obtainMessage(3,1,1,obj);
mOwnLooperThreadHandler.sendMessage(m);
Looper.loop();
}
}
//ReceiveMessageThreadhashisownmessagequeuebyexecuteLooper.prepare();
classReceiveMessageThreadextendsThread{
publicvoidrun(){
Looper.prepare();
mOtherThreadHandler=newHandler(){
publicvoidhandleMessage(Messagemsg){
Log.e(sTag,(String)msg.obj);
}
};
Looper.loop();
}
}
}

package com.android.messageexample;import android.app.Activity;import android.content.Context;import android.graphics.Color;import android.os.Bundle;import android.os.Handler;import android.os.Looper;import android.os.Message;import android.util.Log;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.LinearLayout;import android.widget.TextView;public class MessageExample extends Activity implements OnClickListener { private final int WC = LinearLayout.LayoutParams.WRAP_CONTENT;  private final int FP = LinearLayout.LayoutParams.FILL_PARENT;  public TextView tv;  private EventHandler mHandler;  private Handler mOtherThreadHandler=null;  private Button btn, btn2, btn3, btn4, btn5, btn6;  private NoLooperThread noLooerThread = null;  private OwnLooperThread ownLooperThread = null;  private ReceiveMessageThread receiveMessageThread =null;  private Context context = null;  private final String sTag = "MessageExample";  private boolean postRunnable = false;  /** Called when the activity is first created. */ @Override  public void onCreate(Bundle savedInstanceState) {  super.onCreate(savedInstanceState);  context = this.getApplicationContext();  LinearLayout layout = new LinearLayout(this);  layout.setOrientation(LinearLayout.VERTICAL);  btn = new Button(this);  btn.setId(101);  btn.setText("message from main thread self");  btn.setOnClickListener(this);  LinearLayout.LayoutParams param =    new LinearLayout.LayoutParams(250,50);  param.topMargin = 10;  layout.addView(btn, param);  btn2 = new Button(this);  btn2.setId(102);  btn2.setText("message from other thread to main thread");  btn2.setOnClickListener(this);  layout.addView(btn2, param);  btn3 = new Button(this);  btn3.setId(103);  btn3.setText("message to other thread from itself");  btn3.setOnClickListener(this);  layout.addView(btn3, param);  btn4 = new Button(this);  btn4.setId(104);  btn4.setText("message with Runnable as callback from other thread to main thread");  btn4.setOnClickListener(this);  layout.addView(btn4, param);  btn5 = new Button(this);  btn5.setId(105);  btn5.setText("main thread's message to other thread");  btn5.setOnClickListener(this);  layout.addView(btn5, param);  btn6 = new Button(this);  btn6.setId(106);  btn6.setText("exit");  btn6.setOnClickListener(this);  layout.addView(btn6, param);  tv = new TextView(this);  tv.setTextColor(Color.WHITE);  tv.setText("");  LinearLayout.LayoutParams param2 =   new LinearLayout.LayoutParams(FP, WC);  param2.topMargin = 10;  layout.addView(tv, param2);  setContentView(layout);     //主线程要发送消息给other thread， 这里创建那个other threadreceiveMessageThread = new ReceiveMessageThread();receiveMessageThread.start();  }  //implement the OnClickListener interface @Override public void onClick(View v) {switch(v.getId()){case 101: //主线程发送消息给自己 Looper looper; looper = Looper.myLooper();//get the Main looper related with the main thread //如果不给任何参数的话会用当前线程对应的Looper(这里就是Main Looper)为Handler里面的成员mLooper赋值 mHandler = new EventHandler(looper);  //mHandler = new EventHandler(); // 清除整个MessageQueue里的消息 mHandler.removeMessages(0); String obj = "This main thread's message and received by itself!"; //得到Message对象 Message m = mHandler.obtainMessage(1, 1, 1, obj); // 将Message对象送入到main thread的MessageQueue里面 mHandler.sendMessage(m); break;case 102:   //other线程发送消息给主线程 postRunnable = false; noLooerThread = new NoLooperThread(); noLooerThread.start(); break;case 103: //other thread获取它自己发送的消息 tv.setText("please look at the error level log for other thread received message"); ownLooperThread = new OwnLooperThread(); ownLooperThread.start(); break; case 104:  //other thread通过Post Runnable方式发送消息给主线程 postRunnable = true; noLooerThread = new NoLooperThread(); noLooerThread.start(); break;case 105:  //主线程发送消息给other thread if(null!=mOtherThreadHandler){  tv.setText("please look at the error level log for other thread received message from main thread");  String msgObj = "message from mainThread";  Message mainThreadMsg = mOtherThreadHandler.obtainMessage(1, 1, 1, msgObj);  mOthe

分享到：深入Android 【二】 —— 架构和特征 | IntentFilter

2010-04-27 09:22
浏览 446
评论(0)
分类:移动开发
相关推荐

发表评论

您还没有登录,请您登录后再发表评论

android中Message机制的灵活应用

android中Message机制的灵活应用

评论

发表评论

更多相关文章

随机推荐