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对象会和一个线程关联
Looper对象创建时会创建一个MessageQueue，主线程默认会创建一个Looper从而有MessageQueue，其他线程默认是没有 MessageQueue的不能接收Message，如果需要接收Message则需要通过prepare函数创建一个MessageQueue。具体操作请见示例代码。
prepareMainLooper函数只给主线程调用（系统处理，程序员不用处理），它会调用prepare建立Looper对象和MessageQueue。

1.4.Handler

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

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

Handler类的常用方法

方法签名

描 述

public void handleMessage (Message msg)

子类对象通过该方法接收信息

public final boolean sendEmptyMessage (int what)

发送一个只含有 what 值的消息

public final boolean sendMessage (Message msg)

发送消息到 Handler ，

通过 handleMessage 方法接收

public final boolean hasMessages (int what)

监测消息队列中是否还

有 what 值的消息

public final boolean post (Runnable r)

将一个线程添加到消息队列

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

Java代码 复制代码 收藏代码
  1. publicfinalMessageobtainMessage(intwhat,intarg1,intarg2,Objectobj){
  2. returnMessage.obtain(this,what,arg1,arg2,obj);
  3. }


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

Java代码 复制代码 收藏代码
  1. publicbooleansendMessageAtTime(Messagemsg,longuptimeMillis){
  2. booleansent=false;
  3. MessageQueuequeue=mQueue;
  4. if(queue!=null){
  5. msg.target=this;
  6. sent=queue.enqueueMessage(msg,uptimeMillis);
  7. }else{
  8. RuntimeExceptione=newRuntimeException(this+"sendMessageAtTime()calledwithnomQueue");
  9. Log.w("Looper",e.getMessage(),e);
  10. }
  11. returnsent;
  12. }



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

Java代码 复制代码 收藏代码
  1. publicvoiddispatchMessage(Messagemsg){
  2. if(msg.callback!=null){
  3. handleCallback(msg);
  4. }else{
  5. if(mCallback!=null){
  6. if(mCallback.handleMessage(msg)){
  7. return;
  8. }
  9. }
  10. handleMessage(msg);
  11. }
  12. }


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


从上可知以下关系图：
android message机制_第1张图片
其中清理Message是Looper里面的loop函数指把处理过的Message放到Message的Pool里面去，如果里面已经超过最大值10个，则丢弃这个Message对象。
调用Handler是指Looper里面的loop函数从MessageQueue的接收消息队列里面取出消息，然后根据消息指向的Handler对象调用其对应的处理方法。 在Android 中Handler和Message、Thread有着很密切的关系。Handler 主要是负责Message的分发和处理。但是这个Message从哪里来的呢？Message 由一个消息队列进行管理，而消息队列却由一个Looper进行管理。Android系统中Looper负责管理线程的消息队列和消息循环，具体实现请参考Looper的源码。 可以通过Loop.myLooper()得到当前线程的Looper对象，通过Loop.getMainLooper()可以获得当前进程的主线程的 Looper对象。 Android系统的消息队列和消息循环都是针对具体线程的，一个线程可以存在（当然也可以不存在）一个消息队列和一个消息循环（Looper），特定线程的消息只能分发给本线程，不能进行跨线程，跨进程通讯。但是创建的工作线程默认是没有消息循环和消息队列的，如果想让该线程具有消息队列和消息循环，需要在线程中首先调用Looper.prepare()来创建消息队列，然后调用Looper.loop()进入消息循环。 虽说 特定线程的消息只能分发给本线程，不能进行跨线程通讯，但是由于可以通过获得线程的Looper对象来进行曲线的实现不同线程间消息的传递，代码如下：
  • packagecom.mytest.handlertest;
  • importandroid.app.Activity;
  • 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.view.ViewGroup.LayoutParams;
  • importandroid.widget.Button;
  • importandroid.widget.LinearLayout;
  • importandroid.widget.TextView;
  • publicclassHandlerTestextendsActivityimplementsOnClickListener{
  • privateStringTAG="HandlerTest";
  • privatebooleanbpostRunnable=false;
  • privateNoLooperThreadnoLooperThread=null;
  • privateOwnLooperThreadownLooperThread=null;
  • privateReceiveMessageThreadreceiveMessageThread=null;
  • privateHandlermOtherThreadHandler=null;
  • privateEventHandlermHandler=null;
  • privateButtonbtn1=null;
  • privateButtonbtn2=null;
  • privateButtonbtn3=null;
  • privateButtonbtn4=null;
  • privateButtonbtn5=null;
  • privateButtonbtn6=null;
  • privateTextViewtv=null;
  • /**Calledwhentheactivityisfirstcreated.*/
  • @Override
  • publicvoidonCreate(BundlesavedInstanceState){
  • super.onCreate(savedInstanceState);
  • LinearLayoutlayout=newLinearLayout(this);
  • LinearLayout.LayoutParamsparams=newLinearLayout.LayoutParams(250,50);
  • layout.setOrientation(LinearLayout.VERTICAL);
  • btn1=newButton(this);
  • btn1.setId(101);
  • btn1.setText("messagefrommainthreadself");
  • btn1.setOnClickListener(this);
  • layout.addView(btn1,params);
  • btn2=newButton(this);
  • btn2.setId(102);
  • btn2.setText("messagefromotherthreadtomainthread");
  • btn2.setOnClickListener(this);
  • layout.addView(btn2,params);
  • btn3=newButton(this);
  • btn3.setId(103);
  • btn3.setText("messagetootherthreadfromitself");
  • btn3.setOnClickListener(this);
  • layout.addView(btn3,params);
  • btn4=newButton(this);
  • btn4.setId(104);
  • btn4.setText("messagewithRunnableascallbackfromotherthreadtomainthread");
  • btn4.setOnClickListener(this);
  • layout.addView(btn4,params);
  • btn5=newButton(this);
  • btn5.setId(105);
  • btn5.setText("mainthread'smessagetootherthread");
  • btn5.setOnClickListener(this);
  • layout.addView(btn5,params);
  • btn6=newButton(this);
  • btn6.setId(106);
  • btn6.setText("exit");
  • btn6.setOnClickListener(this);
  • layout.addView(btn6,params);
  • tv=newTextView(this);
  • tv.setTextColor(Color.WHITE);
  • tv.setText("");
  • params=newLinearLayout.LayoutParams(LayoutParams.FILL_PARENT,LayoutParams.WRAP_CONTENT);
  • params.topMargin=10;
  • layout.addView(tv,params);
  • setContentView(layout);
  • receiveMessageThread=newReceiveMessageThread();
  • receiveMessageThread.start();
  • }
  • classEventHandlerextendsHandler{
  • publicEventHandler(Looperlooper){
  • super(looper);
  • }
  • publicEventHandler(){
  • super();
  • }
  • @Override
  • publicvoidhandleMessage(Messagemsg){
  • //TODOAuto-generatedmethodstub
  • super.handleMessage(msg);
  • Log.e(TAG,"CurrentThreadid:----------+>"+Thread.currentThread().getId());
  • switch(msg.what){
  • case1:
  • tv.setText((String)msg.obj);
  • break;
  • case2:
  • tv.setText((String)msg.obj);
  • noLooperThread.stop();
  • break;
  • case3:
  • //不能在非主线程的线程里面更新UI，所以这里通过log打印信息
  • Log.e(TAG,(String)msg.obj);
  • ownLooperThread.stop();
  • break;
  • default:
  • Log.e(TAG,(String)msg.obj);
  • break;
  • }
  • }
  • }
  • //ReceiveMessageThreadhashisownmessagequeuebyexecuteLooper.prepare();
  • classReceiveMessageThreadextendsThread{
  • @Override
  • publicvoidrun(){
  • Looper.prepare();
  • mOtherThreadHandler=newHandler(){
  • @Override
  • publicvoidhandleMessage(Messagemsg){
  • //TODOAuto-generatedmethodstub
  • super.handleMessage(msg);
  • Log.e(TAG,"-------+>"+(String)msg.obj);
  • Log.e(TAG,"CurrentThreadid:----------+>"+Thread.currentThread().getId());
  • }
  • };
  • Log.e(TAG,"ReceiveMessageThreadid:--------+>"+this.getId());
  • Looper.loop();
  • }
  • }
  • classNoLooperThreadextendsThread{
  • privateEventHandlermNoLooperThreadHandler;
  • @Override
  • publicvoidrun(){
  • LoopermyLooper=Looper.myLooper();
  • LoopermainLooper=Looper.getMainLooper();
  • Stringmsgobj;
  • if(null==myLooper){
  • //这里获得的是主线程的Looper,由于NoLooperThread没有自己的looper所以这里肯定会被执行
  • mNoLooperThreadHandler=newEventHandler(mainLooper);
  • msgobj="NoLooperThreadhasnolooperandhandleMessagefunctionexecutedinmainthread!";
  • }else{
  • mNoLooperThreadHandler=newEventHandler(myLooper);
  • msgobj="ThisisfromNoLooperThreadselfandhandleMessagefunctionexecutedinNoLooperThread!";
  • }
  • mNoLooperThreadHandler.removeMessages(0);
  • if(bpostRunnable==false){
  • //sendmessagetomainthread
  • Messagemsg=mNoLooperThreadHandler.obtainMessage(2,1,1,msgobj);
  • mNoLooperThreadHandler.sendMessage(msg);
  • Log.e(TAG,"NoLooperThreadid:--------+>"+this.getId());
  • }else{
  • //下面new出来的实现了Runnable接口的对象中run函数是在MainThread中执行，不是在NoLooperThread中执行记得null==myLooper么
  • //注意Runnable是一个接口，它里面的run函数被执行时不会再新建一个线程
  • //您可以在run上加断点然后在eclipse调试中看它在哪个线程中执行
  • mNoLooperThreadHandler.post(newRunnable(){
  • publicvoidrun(){
  • //TODOAuto-generatedmethodstub
  • tv.setText("updateUIthroughhandlerpostrunnalbemechanism!");
  • Log.e(TAG,"updateUIid:--------+>"+Thread.currentThread().getId());
  • noLooperThread.stop();
  • }
  • });
  • }
  • }
  • }
  • classOwnLooperThreadextendsThread{
  • privateEventHandlermOwnLooperThreadHandler=null;
  • @Override
  • publicvoidrun(){
  • Looper.prepare();
  • LoopermyLooper=Looper.myLooper();
  • LoopermainLooper=Looper.getMainLooper();
  • Stringmsgobj;
  • if(null==myLooper){
  • mOwnLooperThreadHandler=newEventHandler(mainLooper);
  • msgobj="OwnLooperThreadhasnolooperandhandleMessagefunctionexecutedinmainthread!";
  • }else{
  • mOwnLooperThreadHandler=newEventHandler(myLooper);
  • msgobj="ThisisfromOwnLooperThreadselfandhandleMessagefunctionexecutedinNoLooperThread!";
  • }
  • mOwnLooperThreadHandler.removeMessages(0);
  • //给自己发送消息
  • Messagemsg=mOwnLooperThreadHandler.obtainMessage(3,1,1,msgobj);
  • mOwnLooperThreadHandler.sendMessage(msg);
  • Looper.loop();
  • }
  • }
  • publicvoidonClick(Viewv){
  • //TODOAuto-generatedmethodstub
  • switch(v.getId()){
  • case101:
  • //主线程发送消息给自己
  • Looperlooper=Looper.myLooper();//gettheMainlooperrelatedwiththemainthread
  • //如果不给任何参数的话会用当前线程对应的Looper(这里就是MainLooper)为Handler里面的成员mLooper赋值
  • mHandler=newEventHandler(looper);
  • //清除整个MessageQueue里的消息
  • mHandler.removeMessages(0);
  • Stringobj="Thismainthread'smessageandreceivedbyitself!";
  • Messagemsg=mHandler.obtainMessage(1,1,1,obj);
  • //将Message对象送入到mainthread的MessageQueue里面
  • mHandler.sendMessage(msg);
  • break;
  • case102:
  • //other线程发送消息给主线程
  • bpostRunnable=false;
  • noLooperThread=newNoLooperThread();
  • noLooperThread.start();
  • break;
  • case103:
  • //otherthread获取它自己发送的消息
  • tv.setText("pleaselookattheerrorlevellogforotherthreadreceivedmessage");
  • ownLooperThread=newOwnLooperThread();
  • ownLooperThread.start();
  • break;
  • case104:
  • //otherthread通过PostRunnable方式发送消息给主线程
  • bpostRunnable=true;
  • noLooperThread=newNoLooperThread();
  • noLooperThread.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;
  • }
  • }
  • }

    • 更多相关文章

    1. 第10章 Android的消息机制
    2. Android多线程下载远程图片
    3. Android应用程序消息处理机制（Looper、Handler）分析（4）
    4. Android开发实践：自定义带消息循环（Looper）的工作线程

    随机推荐

    1. 屏幕锁知识点
    2. Android(安卓)studio JNI开发
    3. Android布局动画之animateLayoutChanges
    4. 2011.06.09——— android 1.6 launcher
    5. android的自动更新
    6. Android（OPhone） 学习笔记 - 地图（2）
    7. Android(安卓)5.0 android:elevation 如
    8. Android(安卓)Virtual Device仿真界面对
    9. Android退出时关闭所有Activity的方法
    10. Google I/O大会发布Android(安卓)Studio，