`

剖析Android消息机制

 
阅读更多
剖析Android消息机制
在Android中,线程内部或者线程之间进行信息交互时经常会使用消息,这些基础的东西如果我们熟悉其内部的原理,将会使我们容易、更好地架构系统,避免一些低级的错误。在学习Android中消息机制之前,我们先了解与消息有关的几个类:

1.Message

消息对象,顾名思义就是记录消息信息的类。这个类有几个比较重要的字段:

a.arg1和arg2:我们可以使用两个字段用来存放我们需要传递的整型值,在Service中,我们可以用来存放Service的ID。

b.obj:该字段是Object类型,我们可以让该字段传递某个多项到消息的接受者中。

c.what:这个字段可以说是消息的标志,在消息处理中,我们可以根据这个字段的不同的值进行不同的处理,类似于我们在处理Button事件时,通过switch(v.getId())判断是点击了哪个按钮。

在使用Message时,我们可以通过new Message()创建一个Message实例,但是Android更推荐我们通过Message.obtain()或者Handler.obtainMessage()获取Message对象。这并不一定是直接创建一个新的实例,而是先从消息池中看有没有可用的Message实例,存在则直接取出并返回这个实例。反之如果消息池中没有可用的Message实例,则根据给定的参数new一个新Message对象。通过分析源码可得知,Android系统默认情况下在消息池中实例化10个Message对象。

2.MessageQueue

View Code
消息队列,用来存放Message对象的数据结构,按照“先进先出”的原则存放消息。存放并非实际意义的保存,而是将Message对象以链表的方式串联起来的。MessageQueue对象不需要我们自己创建,而是有Looper对象对其进行管理,一个线程最多只可以拥有一个MessageQueue。我们可以通过Looper.myQueue()获取当前线程中的MessageQueue。3.LooperMessageQueue的管理者,在一个线程中,如果存在Looper对象,则必定存在MessageQueue对象,并且只存在一个Looper对象和一个MessageQueue对象。在Android系统中,除了主线程有默认的Looper对象,其它线程默认是没有Looper对象。如果想让我们新创建的线程拥有Looper对象时,我们首先应调用Looper.prepare()方法,然后再调用Looper.loop()方法。典型的用法如下:class LooperThread extends Thread{    public Handler mHandler;    public void run()    {        Looper.prepare();        //其它需要处理的操作        Looper.loop();    }}
倘若我们的线程中存在Looper对象,则我们可以通过Looper.myLooper()获取,此外我们还可以通过Looper.getMainLooper()获取当前应用系统中主线程的Looper对象。在这个地方有一点需要注意,假如Looper对象位于应用程序主线程中,则Looper.myLooper()和Looper.getMainLooper()获取的是同一个对象。

4.Handler

消息的处理者。通过Handler对象我们可以封装Message对象,然后通过sendMessage(msg)把Message对象添加到MessageQueue中;当MessageQueue循环到该Message时,就会调用该Message对象对应的handler对象的handleMessage()方法对其进行处理。由于是在handleMessage()方法中处理消息,因此我们应该编写一个类继承自Handler,然后在handleMessage()处理我们需要的操作。

下面我们通过跟踪代码分析在Android中是如何处理消息。首先贴上测试代码:

View Code
/** *  * @author coolszy * @blog http://blog.csdn.net/coolszy * */public class MessageService extends Service{    private static final String TAG = "MessageService";    private static final int KUKA = 0;     private Looper looper;    private ServiceHandler handler;     /**     * 由于处理消息是在Handler的handleMessage()方法中,因此我们需要自己编写类     * 继承自Handler类,然后在handleMessage()中编写我们所需要的功能代码     * @author coolszy     *     */    private final class ServiceHandler extends Handler    {        public ServiceHandler(Looper looper)        {            super(looper);        }         @Override        public void handleMessage(Message msg)        {            // 根据what字段判断是哪个消息            switch (msg.what)            {            case KUKA:                //获取msg的obj字段。我们可在此编写我们所需要的功能代码                Log.i(TAG, "The obj field of msg:" + msg.obj);                break;            // other cases            default:                break;            }            // 如果我们Service已完成任务,则停止Service            stopSelf(msg.arg1);        }    }     @Override    public void onCreate()    {        Log.i(TAG, "MessageService-->onCreate()");         // 默认情况下Service是运行在主线程中,而服务一般又十分耗费时间,如果        // 放在主线程中,将会影响程序与用户的交互,因此把Service        // 放在一个单独的线程中执行        HandlerThread thread = new HandlerThread("MessageDemoThread", Process.THREAD_PRIORITY_BACKGROUND);        thread.start();         // 获取当前线程中的looper对象        looper = thread.getLooper();        //创建Handler对象,把looper传递过来使得handler、        //looper和messageQueue三者建立联系        handler = new ServiceHandler(looper);    }     @Override    public int onStartCommand(Intent intent, int flags, int startId)    {        Log.i(TAG, "MessageService-->onStartCommand()");         //从消息池中获取一个Message实例        Message msg = handler.obtainMessage();        // arg1保存线程的ID,在handleMessage()方法中        // 我们可以通过stopSelf(startId)方法,停止服务        msg.arg1 = startId;        // msg的标志        msg.what = KUKA;        // 在这里我创建一个date对象,赋值给obj字段        // 在实际中我们可以通过obj传递我们需要处理的对象        Date date = new Date();        msg.obj = date;        // 把msg添加到MessageQueue中        handler.sendMessage(msg);         return START_STICKY;    }     @Override    public void onDestroy()    {        Log.i(TAG, "MessageService-->onDestroy()");    }     @Override    public IBinder onBind(Intent intent)    {        return null;    }}
运行结果:



注:在测试代码中我们使用了HandlerThread类,该类是Thread的子类,该类运行时将会创建looper对象,使用该类省去了我们自己编写Thread子类并且创建Looper的麻烦。

下面我们分析下程序的运行过程:

1.onCreate()

首先启动服务时将会调用onCreate()方法,在该方法中我们new了一个HandlerThread对象,提供了线程的名字和优先级。

紧接着我们调用了start()方法,执行该方法将会调用HandlerThread对象的run()方法:

View Code
public void run() {        mTid = Process.myTid();        Looper.prepare();        synchronized (this) {            mLooper = Looper.myLooper();            notifyAll();        }        Process.setThreadPriority(mPriority);        onLooperPrepared();        Looper.loop();        mTid = -1;    }
在run()方法中,系统给线程添加的Looper,同时调用了Looper的loop()方法:

View Code
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();            }        }    }
通过源码我们可以看到loop()方法是个死循环,将会不停的从MessageQueue对象中获取Message对象,如果MessageQueue 对象中不存在Message对象,则结束本次循环,然后继续循环;如果存在Message对象,则执行 msg.target.dispatchMessage(msg),但是这个msg的.target字段的值是什么呢?我们先暂时停止跟踪源码,返回到onCreate()方法中。线程执行完start()方法后,我们可以获取线程的Looper对象,然后new一个ServiceHandler对象,我们把Looper对象传到ServiceHandler构造函数中将使handler、looper和messageQueue三者建立联系。

2.onStartCommand()

执行完onStart()方法后,将执行onStartCommand()方法。首先我们从消息池中获取一个Message实例,然后给Message对象的arg1、what、obj三个字段赋值。紧接着调用sendMessage(msg)方法,我们跟踪源代码,该方法将会调用sendMessageDelayed(msg, 0)方法,而sendMessageDelayed()方法又会调用sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis)方法,在该方法中我们要注意该句代码msg.target = this,msg的target指向了this,而this就是ServiceHandler对象,因此msg的target字段指向了ServiceHandler对象,同时该方法又调用MessageQueue 的enqueueMessage(msg, uptimeMillis)方法:

View Code
final boolean enqueueMessage(Message msg, long when) {        if (msg.when != 0) {            throw new AndroidRuntimeException(msg                    + " This message is already in use.");        }        if (msg.target == null && !mQuitAllowed) {            throw new RuntimeException("Main thread not allowed to quit");        }        synchronized (this) {            if (mQuiting) {                RuntimeException e = new RuntimeException(                    msg.target + " sending message to a Handler on a dead thread");                Log.w("MessageQueue", e.getMessage(), e);                return false;            } else if (msg.target == null) {                mQuiting = true;            }             msg.when = when;            //Log.d("MessageQueue", "Enqueing: " + msg);            Message p = mMessages;            if (p == null || when == 0 || when < p.when) {                msg.next = p;                mMessages = msg;                this.notify();            } else {                Message prev = null;                while (p != null && p.when <= when) {                    prev = p;                    p = p.next;                }                msg.next = prev.next;                prev.next = msg;                this.notify();            }        }        return true;    }
该方法主要的任务就是把Message对象的添加到MessageQueue中(数据结构最基础的东西,自己画图理解下)。

handler.sendMessage()-->handler.sendMessageDelayed()-->handler.sendMessageAtTime()-->msg.target = this;queue.enqueueMessage==>把msg添加到消息队列中

3.handleMessage(msg)

onStartCommand()执行完毕后我们的Service中的方法就执行完毕了,那么handleMessage()是怎么调用的呢?在前面分析的loop()方法中,我们当时不知道msg的target字段代码什么,通过上面分析现在我们知道它代表ServiceHandler对象,msg.target.dispatchMessage(msg);则表示执行ServiceHandler对象中的dispatchMessage()方法:

View Code
public void dispatchMessage(Message msg) {        if (msg.callback != null) {            handleCallback(msg);        } else {            if (mCallback != null) {                if (mCallback.handleMessage(msg)) {                    return;                }            }            handleMessage(msg);        }    }
该方法首先判断callback是否为空,我们跟踪的过程中未见给其赋值,因此callback字段为空,所以最终将会执行handleMessage()方法,也就是我们ServiceHandler类中复写的方法。在该方法将根据what字段的值判断执行哪段代码。

至此,我们看到,一个Message经由Handler的发送,MessageQueue的入队,Looper的抽取,又再一次地回到Handler的怀抱中。而绕的这一圈,也正好帮助我们将同步操作变成了异步操作。

分享到:
评论

相关推荐

    深入剖析Android消息机制

    在Android开发中,消息机制是实现线程间通信的关键技术之一。它允许我们在不同线程中发送和接收信息,使得线程的交互与协同工作变得可行。了解Android消息机制的内部原理,对于设计稳定、高效的多线程应用架构至关...

    深入剖析Android消息机制.pdf

    Android消息机制是Android应用程序开发中的核心机制之一,它涉及线程间通信(IPC)和线程内部的事件驱动,是实现异步消息处理的重要方式。Android消息机制主要基于Handler、Looper和MessageQueue这三个组件协同工作...

    源码分析Android的消息机制

    本文计划在较短的篇幅内,通过一定的源码,分析Android消息机制,并在结尾说点”题外话“,帮助我们理解消息机制在安卓应用中的作用。 二、Android消息队列与四大组件的关系 ​Android的消息机制伴随着安卓四大组件...

    android开发教程深入剖析Android消息机制借鉴.pdf

    理解并熟练掌握Android的消息机制对开发者来说至关重要,它有助于构建高效、健壮的多线程应用程序,避免UI线程阻塞,提升用户体验。通过Handler,开发者可以在后台线程与主线程间安全地传递数据和执行异步操作,实现...

    android 消息机制

    从源码出发,详细的解析了android中的消息机制,分析清楚Looper和MessageQueue以及Handler三者之间的关系。

    Android核心机制深入分析

    《Android核心机制深入分析》是针对Android系统内部工作原理的一篇详尽研究,旨在帮助开发者深化对Android系统核心机制的理解。这份PDF文档由TerryLog的分析整理而成,涵盖了Android的多个关键层面,包括但不限于...

    Android主要机制深入分析.pdf

    深入分析Android机制有助于开发者更有效地进行应用开发、系统定制和故障排查。通过从抽象层出发理解Android的设计意图,然后逐步深入到具体代码和实现细节,是研究Android系统的有效方法。通过分析这些核心机制,...

    Android消息机制资料及源码

    通过阅读和分析这个例子,你可以更好地理解消息机制的实际应用。 三篇PDF资料很可能会分别从基础理论、源码解析和实战应用三个角度来深入探讨Android的消息机制。它们可能涵盖了Looper的内部实现、Message的生命...

    代码分析Android消息机制

    Handler、MessageQueue和Looper构成了Android的消息处理机制。Handler负责发送消息和处理消息,Message作为消息载体,包含了处理逻辑和数据,而Looper则是负责不断循环地从MessageQueue中取出消息并分发给相应的...

    Android 提高篇 机制 分析

    ### Android提高篇机制分析 #### 一、设计方法论探讨之设计意图...综上所述,本文档旨在从设计意图的角度出发,全面分析Android系统的核心机制,帮助开发者更好地理解Android的内部工作原理,从而提升开发效率和质量。

    从现实生活中理解android 线程消息机制

    在Android系统中,线程消息机制是一个核心概念,它确保了应用程序的高效运行和用户体验的流畅性。这个机制主要由三部分组成:Handler、Looper和Message Queue。下面我们将从现实生活中的例子来深入理解这个机制,并...

    Android中消息机制分析

    对于Android开发者而言,我们处理异步消息用的最多的也是轻车熟路的一种方式,就是使用Handler进行消息的分发和处理。但是我们在一个页面(Activity 或者 Fragment)中可以直接使用Handler进行消息的分发和处理。...

    Android Dalvik虚拟机结构及机制剖析 第2卷.pdf

    但我可以根据标题所揭示的主题,即“Android Dalvik虚拟机结构及机制剖析”,来生成相关的知识点。 Dalvik是Android操作系统中用于执行应用程序的虚拟机。它专为移动设备优化,使得Android应用能够高效运行。Dalvik...

    Android主要机制深入分析

    ### Android主要机制深入分析 #### 一、设计方法论探讨之设计意图 在探究Android复杂的内部运作机制之前,我们首先要明确研究的方向与目的。对于一个跨平台开发者来说,理解Android的核心在于把握其设计理念与实现...

    Android消息机制

    通过上述分析可以看出,Android中的`Handler`机制是一种非常高效且灵活的消息传递机制。它通过消息循环、消息发送以及消息处理三个关键环节,实现了不同线程间的信息传递与交互。无论是主线程还是子线程,都可以利用...

    Android操作系统安全机制研究.doc

    本文将深入探讨Android的安全体系结构,分析现有的安全机制,并提出针对性的解决方案。 Android系统的基本构架由应用层、应用程序框架层、系统运行时类库层和Linux内核层组成。这一层次化设计旨在兼顾安全性和开放...

    android多线程机制

    Android的消息机制主要包括以下几个关键组件: 1. **Message**:消息的载体,用于封装数据或命令。可以通过`Message`对象传递数据或指示某个事件的发生。 2. **MessageQueue**:消息队列,用于存储待处理的消息。...

Global site tag (gtag.js) - Google Analytics