Android中Hander处理消息和Runnable详细过程分析

      接触android也有一段时间了，说实话真的感觉google很伟大，用那么基础的技术却做出那么神秘的东西，也同时为google提出“随时随地为你提供信息!”而感动，当然这都是我个人的真实感受，还是开始正文吧。

      在android开发中处理耗时的工作一般都推荐AsyncTask，这个我也确实喜欢，但是我最先接触的确实Handler，而且直到今天我也没有彻底搞清楚，凡事不能总是逃避，只有一次性的解决才能安心，那就从handler开始吧：

      handler发送Message :

 

    public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }

 

上面是Handler类的sendMessage方法，这里他调用了另一个方法，继续追踪：

    public final boolean sendMessageDelayed(Message msg, long delayMillis)
    {
        if (delayMillis < 0) {
            delayMillis = 0;
        }
        return sendMessageAtTime(msg, SystemClock.uptimeMillis() + delayMillis);
    }

不多说继续追踪：

 

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;
    }
此方法执行后Message入队了。

 

Handler类中的操作暂时告一段落，Looper在主线程里面等不及了。

 

 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();
            }
        }
    }

 

从消息队列里面拿出消息，注意这一步 msg.target.dispatchMessage(msg); 还记得 Handler中sendMessageAtTime()方法里面的这行代码吧， msg.target = this; 这里调用的dispatchMessage是刚才那个发送消息的Handler，OK，再回到Handler类中看看dispatchMessage()到底是什么东东。

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

 

上面的if判断先白不用看，这个是处理Runnbale的，直接看看这个handleMessage(msg);哈哈，终于看见我们所熟悉的方法了，Handler中这个方法是构造方法，到这里你应该明白了对于Message的处理了吧。

 

在看看对于Runnable的处理，先去看看handler的post()方法：

 

public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }

接着追..

 

 

 private final Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }

 

 

注意这行   m.callback = r; 我们一开始post()进来的Runnable到这里了，被赋值到Message的callback属性上了，直接把这个带有特殊属性的Message放入队列了。

然后Looper处理后回调到我们的handler类里面的此方法：

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

现在这里的if判断对我们来说已经有意义了。

 if (msg.callback != null) {
            handleCallback(msg);
        }

这里msg.callback当然不为null，那就执行 handleCallback(msg);吧，

 

 

private final void handleCallback(Message message) {
        message.callback.run();
    }

我靠，直接调用run()方法。

这里大致摸清了整个过程。

 

其实我只是想说的是对于简单的耗时操作没必要用AsyncTask，不然就泛滥了。