“刨根问底”之Android 消息机制

首先我们要明白的一个问题是Android为什么会设计这样一个“消息机制”，它有什么作用？？

 

要解答这个问题，我们首先要了解，Andorid中的UI控件都是运行在我们应用程序中的主线程中，它们是非线程安全的，也就说所有涉及到UI的相关操作都只能在主进程中进行操作，如果要进行跨线程的操作会报异常。

错误示例代码如下：

TextView textView;
Override
ublic void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   setContentView(R.layout.main);

   textView = (TextView) findViewById(R.id.textView);
   Button btnAdd = (Button) findViewById(R.id.btnAdd);
   btnAdd.setOnClickListener(new View.OnClickListener() {

       @Override
       public void onClick(View v) {

           //开启一个线程执行更新UI操作
           new Thread(new Runnable() {

               @Override
               public void run() {

                   //......执行一些费时的操作（省略）


                   //执行成功之后将textview上的文字改为成功
                   textView.setText("操作成功!");

               }

           }).start();
       }

   });



毫无疑问，上面的代码肯定会报错（textView是UI控件，只能在主线程进行操作）。那么要怎么解决这个问题呢,这时候就需要用到Android中的“消息机制”了，

 

要了解消息机制，我们先来了解下这里面涉及到五个关键对象:

Message： 消息对象，包含了一些描述信息和数据。
Handler:     负责消息对象的传递与处理（使用该类时我们必须先继承Handler类，然后重写Handler类中的handlerMessage(msg) 方法，在此方法中进行相关处理操作，如： 更新UI ）
MessageQueue: 消息队列。存储由Handler发送过来的Message对象。
Looper:  负责为当前线程运行一个消息循环（MessageQueue）。它会循环抽取MessageQueue中的Message，并通过handler对象将其分发并处理。

消息机制的完整流程：

1. 生成消息

 

Message msg = handler.obtainMessage() / Message.obtain()

 

注意：虽然Message有公有的构造方法，但是建议还是使用上面写的这两种方法。因为，在调用这两个方法时，会去对象池中获取可重复利用的Message对象，避免了重新创建。

 

2.  发送消息

 

handler.sendMessage(msg);  或者 message.sendToTarget();   (它其实内部也是调用了handler.sendMessage(msg)方法)

 

接下来 我们通过分析源码来探究下“发送消息”这个操作的内部机制

 

通过查看源码我们可以了解sendMessage() 只是调用了Handler类中的sendMessageAtTime（），所以这里我们只用分析此方法就行-----源码如下：

 类： Handler   -451行

public boolean sendMessageAtTime(Message msg, long uptimeMillis)
{
    boolean sent = false;
    MessageQueue queue = mQueue; // 3. 问题：mQueue 从何而来？？？？
    if (queue != null) {
        // 1. 将当前的handler对象保存在message的target属性中
        msg.target = this;
         // 2. 将message对象放入MessageQueue中
        sent = queue.enqueueMessage(msg, uptimeMillis);
    }
    else {
        RuntimeException e = new RuntimeException(
            this + " sendMessageAtTime() called with no mQueue");
        Log.w("Looper", e.getMessage(), e);
    }
    return sent;
}

 

上面的这个方法，其实只是做了两个操作：       

        1. 将当前对象(handler)保存在message.target 中， 方便在处理消息对象时使用。

        2. 将message对象存入到MessageQueue-- （入队）。 其实 MessageQueue 类似于我们的链表结构，我们入队的Message对象遵循“先进先出”的原则，越早被入队的Message，会被越早处理。

        除了以上的这两个操作，上面的源码中还留了一个问题？

        3. 该方法中出现的MessageQueue从何而来？？ 下面我们来仔细探讨下：

             从刚才的sendMessageAtTime() 我们知道， 将message入队到MessageQueue对象实际上是 Handler 类中一个成员变量 : mQueue  。它是在Handler的构造放被初始化的，接下来我们来看下源码中Handler的构造方法：

 

类： Handler   -109行

public Handler() {
    if (FIND_POTENTIAL_LEAKS) {
        final Class<? extends Handler> klass = getClass();
        if ((klass.isAnonymousClass() || klass.isMemberClass() || klass.isLocalClass()) &&
                (klass.getModifiers() & Modifier.STATIC) == 0) {
            Log.w(TAG, "The following Handler class should be static or leaks might occur: " +
                klass.getCanonicalName());
        }
    }
    // 获取Looper对象
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    //从Looper对象中拿到MessageQueue对象并赋值给Handler类中的成员变量mQueue
    mQueue = mLooper.mQueue;
    mCallback = null;
}

   从以上代码可知，MessageQueue 对象 实际是位于Looper类中，，在构造handler对象的时候，我们从Looper中取出，并将其赋值给handle类中的成员变量。

   到这里我想大家已经能明白： “发送消息”这个操作的内部操作：通过调用handler.sendMessage(msg) 方法，将传入的message对象传入到Looper对象(此对象唯一关联一个线程对象)的消息队列(MessageQueue)当中,等待被处理。

 

3. 执行消息

 

在第二步操作中我们已经知道，消息对象已经被handler发送到Looper中的MessageQueue中了。那么接下来该Message对象又做了什么呢？？它最终又是怎么被执行的呢？？

 

首先，我们先在Looper的源码中找到存放的消息对象的MessageQueue

//.... 部分代码省略
public class Looper {

    final MessageQueue mQueue;

    //在构造方法中对MessageQueue对象进行初始化
    private Looper() {

        mQueue = new MessageQueue();

    }
}

 

接下来我们来看下，传入的Looper类中MessageQueue中的消息对象又是怎么执行的呢？

类： Looper -106行

public static final void loop() {
    Looper me = myLooper();
    MessageQueue queue = me.mQueue;
    while (true) {
        Message msg = queue.next();
        if (msg != null) {
            if (msg.target == null) {
                return;
            }
            msg.target.dispatchMessage(msg);

            msg.recycle();
        }
    }
}

 

通过查看上面的源码我们看到，Looper类中有一个Loop() 方法，它里面维护了一个死循环，负责抽取该类中的MessageQueue中的消息对象，然后该消息对象被对应的handler对象（在第二步我们已经知道，handler对象已经被保存在msg的 target属性上了）， 传到 handler 对象中的dispatchMessage方法中。 源码如下：

类： Handler -90行

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

 

在此处方法中只是回调了handler.handlerMessage(msg) 方法， 该处理方法默认为空 。 所以，如果我们要对message进行的处理的话，必须继承Handler类然后重写handlerMessage方法，来完成自己的处理。例如：更新 UI。

 

 

好的,到这里Android的消息机制我们已经大概明白了， 过程如下：

 

   ①生成消息(生成Message对象)

       –》

   ②发送消息(消息入队) –》

 

   ③ 执行消息

          (Loop()方法将Message从消息队列中抽取出并传递到与Message相关的handler对象中)

             – 》

          我们重写handler方法中的handlerMessage() 进行相关处理

 

正确示例代码如下：

public class HandlerDemoActivity extends Activity {

    TextView textView;
    MyHandler myHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        //生成handler对象（注意: handler对象的创建位置非常关键，这个待会儿会详解）
        myHandler = new MyHandler();

        textView = (TextView) findViewById(R.id.textView);
        Button btnAdd = (Button) findViewById(R.id.btnAdd);
        btnAdd.setOnClickListener(new View.OnClickListener() {

            @Override
            public void onClick(View v) {

                //开启一个线程执行更新UI操作
                new Thread(new Runnable() {
                    Handler handler;
                    @Override
                    public void run() {

                        //......执行一些费时的操作（省略）


                        //执行成功之后将textview上的文字改为成功
                        //textView.setText("操作成功!");-- 这是错误的


                        // 1. 生成消息
                        Message message = handler.obtainMessage();
                        //message.setData(data); 可以设置一些参数数据

                        // 2. 发送消息
                        handler.sendMessage(message);


                    }

                }).start();
            }

        });
    }

    //继承Handler类，并重写handlerMessage方法
    class MyHandler extends Handler{


        public MyHandler() {
            super();

        }

        //3. 处理Message
        @Override
        public void handleMessage(Message msg) {


            textView.setText("操作成功!");

        }
    }
}

 

上面的代码是一个完整的Android消息机制实现，我们先来通过代码重温下 Android消息机制的过程：

       ① 示例代码第30行：

             创建了一个消息对象（我们可以设置一些额外的数据，通过Message对象上的属性）

       ② 示例代码第39行：

             将创建的消息对象发送出去，该消息对象会被发送到Looper中的MessageQueue中。

       ③Looper类源码第106行：（ Loop() 方法 ）

public static final void loop() {
    Looper me = myLooper();
    MessageQueue queue = me.mQueue;
    while (true) {
        Message msg = queue.next();
        if (msg != null) {
            if (msg.target == null) {
                return;
            }
            msg.target.dispatchMessage(msg);

            msg.recycle();
        }
    }
}

        循环MessageQueue并调用所对应的hangdler对象的dispatchMessage(msg) 方法，将其分发出去，被分发出去的方法将会在Handler的handlerMessage方法接收到。

      ④ 示例代码第61行： （handlerMessage() 方法）

        我们消息对象终于到到“目的地”，并且可以被处理了。

 

 

通过这个过程我们发现 Message对象是由handler发送，然后绕了一大圈儿之后又被送回到handler对象, 并进行相应的处理。 它之所以这么“麻烦”就是为了变相解决“在别的线程操作UI” 的问题。----- 在其它线程中进行一些相关操作（一般是比较费时的）后，并不是在当前线程中更新UI，而是传递一个消息到与UI线程相关联的Looper中，  然后会在Looper中的Loop方法被抽取并传送至handler对象的handlerMessage方法。

 

最后，我们还要解决一个疑问就是： 为什么能在handler中进行UI操作 -- textView.setText("操作成功!"); --- 示例代码 39 行

 

答案的关键点就是handler对象的创建位置：

 

public class HandlerDemoActivity extends Activity {

    TextView textView;
    MyHandler myHandler;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        //生成handler对象（此操作是在UI主线程中）
        myHandler = new MyHandler();

       //..........以下代码省略

 

从上面代码我们看出来我们的handler对象实际是在UI线程中创建的，，当我们创建在UI线程中创建handler对象时，android会将此对象和当前UI线程对象中的消息队列绑定, 源码如下：

public Handler() {

    //.... 部分代码省略

    //从当前线程中取出Looper对象并向其赋值给Handler的成员变量mLooper
    mLooper = Looper.myLooper();
    if (mLooper == null) {
        throw new RuntimeException(
            "Can't create handler inside thread that has not called Looper.prepare()");
    }
    // 从Looper中取出MessageQueue对象并赋值
    mQueue = mLooper.mQueue;
    mCallback = null;
}

下面是Looper.myLooper()方法的源码：

public static final Looper myLooper() {
    //从当前线程中获取Looper对象
    return (Looper)sThreadLocal.get();
}

 

通过这两段代码我们就明白了，handler其实是间接关联（handler关联Looper，而Looper又唯一对应一个线程，并负责为当前线程运行消息循环）当前线程对象，如果当前线程是UI线程的话那么我们就可以处理同在UI线程中的UI控件了。

 

另外，有一点要提醒的就是，如果我们的Handler对象不是在UI线程中进行初始化的，那么我们就得自己为当前线程构造一个Looper对象，如果要运行的话还得自己启动位于Looper中的消息循环(Loop()方法). 示例代码如下：

class LooperThread extends Thread {
     public Handler mHandler;

     public void run() {
         //构造一个Looper对象，并向其放入到当前线程中（感兴趣的同学可以通过源码查看明细）
         Looper.prepare();

         mHandler = new Handler() {
             public void handleMessage(Message msg) {
                 // process incoming messages here
             }
         };

         //启动消息处理循环
         Looper.loop();
     }
 }

如果handler是在UI线程中进行构造的，那么上面代码中注释的两句代码，android会自动帮我们执行。

 

 

ok, 到此，此文结束！