Android开发之十六：Message、MessageQueue、Looper、Handler原理知识点源码分析

概述

handler作为android消息处理的重要机制，全面回顾下其涉及的知识点。

关键类

整个消息处理机制中涉及到的主要类有： 
Message : 负责消息封装 
MessageQueue : 负责将消息封装为消息队列 
Looper : 负责从消息队列中获取消息并分发 
Handler : 负责消息发送及处理

Message

看看代码中的类注释:

定义包含描述和任意数据对象的消息，发送到Handler。 该对象包含两个额外的int字段和一个额外的对象字段，允许您在很多情形下不用分配新的对象。 
虽然Message的构造函数是公共的，但最好的方法是是调用Message.obtain()或其Handler.obtainMessage()方法，从缓存池中获取一个Message对象。

讲的还是比较清楚,Mesasge的职责就是包装数据,缓存和生成Message。 
那么来看看Message对象中的关键字段和方法:

public final class Message implements Parcelable {

    //在handler处理消息时,用于区分消息内容
    public int what;
    //可携带int参数
    public int arg1; 
    //可携带int参数
    public int arg2;
    //包装的消息对象
    public Object obj;

    //缓存池对象
    private static Message sPool;
    Message next;
    private static int sPoolSize = 0;
    //缓存池的大小
    private static final int MAX_POOL_SIZE = 50;

     //从全局的缓存池中获取一个新的Mesasge实例,避免分配新的对象
    public static Message obtain() {
        synchronized (sPoolSync) {
            if (sPool != null) {
                Message m = sPool;
                sPool = m.next;
                m.next = null;
                m.flags = 0; // clear in-use flag
                sPoolSize--;
                return m;
            }
        }
        return new Message();
    }

    //Message本身携带了target对象,也就是目标handler
    //因此消息可以通过target进行发送
    public void sendToTarget() {
        target.sendMessage(this);
    }
//message对象的回收缓存
void recycleUnchecked() {
        // Mark the message as in use while it remains in the recycled object pool.
        // Clear out all other details.
        flags = FLAG_IN_USE;
        what = 0;
        arg1 = 0;
        arg2 = 0;
        obj = null;
        replyTo = null;
        sendingUid = -1;
        when = 0;
        target = null;
        callback = null;
        data = null;

        synchronized (sPoolSync) {
            if (sPoolSize < MAX_POOL_SIZE) {
                next = sPool;
                sPool = this;
                sPoolSize++;
            }
        }
    }
}

sPool是一个链表结构,在obtain()方法中,sPool为空的话将直接返回一个新的Message对象,如果不为空,那么就取当前对象返回,注意该方法使用synchronized进行代码块同步。 
Message当中还存在其他的一些方法,基本都是用来辅助Message的构建和缓存的,这里不在列出了。

MessageQueue

看看代码中的类注释:

低级别类，包含要由Looper调度的消息列表。 消息不会直接添加到MessageQueue， 而是通过与Looper相关联的Handler对象。 
您可以使用Looper.myQueue()检索当前线程的MessageQueue 。

由Looper类来进行调度,Message是由Handler对象处理才能放入MessageQueue中。 
其中关键的字段和方法:

public final class MessageQueue {
    Message mMessages;
    //将Mesage入队
    boolean enqueueMessage(Message msg, long when) {

            //...省略代码
                Message p = mMessages;
             //...省略代码

            if (p == null || when == 0 || when < p.when) {
                //mMessages是空的,或者如果新msg的执行时间为0，或者小于当前mMessages的时间
                //那么msg会成为链表的新头部
                msg.next = p;
                mMessages = msg;
                needWake = mBlocked;
            } else {
                Message prev;
                for (;;) {
                    prev = p;
                    p = p.next;
                    //一直找到队尾或者执行时间小于找到的message的时间
                    if (p == null || when < p.when) {
                        break;
                    }
                    if (needWake && p.isAsynchronous()) {
                        needWake = false;
                    }
                }
                //然后把新的msg插入进去
                msg.next = p; // invariant: p == prev.next
                prev.next = msg;
            //...省略代码
          }
    }
//获取Message
Message next() {
    //...省略代码
    Message prevMsg = null;
    Message msg = mMessages;
    //...省略代码
      for (;;) {
        if (prevMsg != null) {
           prevMsg.next = msg.next;
       } else {
           mMessages = msg.next;
       }
       msg.next = null;
       if (DEBUG) Log.v(TAG, "Returning message: " + msg);
       msg.markInUse();
       return msg;
    }
}

总的来说Looper负责消息的入队和出队,主要根据Message的执行时间来确定Message在链表中的位置,时间越小，在队列的中的位置就越靠前,被Handler执行的就越早。

Looper

类注释:

用于为线程运行消息循环的类。 默认情况下线程 没有与之关联的消息循环; 调用prepare方法来创建一个Looper对象来运行循环的线程中，然后调用loop方法让它处理消息，直到循环停止。 
大多数与消息循环的交互都会通过Handler对象。

意思就是我们可以通过Looper.prepare()方法来获取一个当前线程的Looper对象。 
其中关键的字段和方法:

public final class Looper {
    //当前线程的ThreadLocal,保存了Looper对象  
    static final ThreadLocal<Looper> sThreadLocal = new ThreadLocal<Looper>();
    //application 的主Looper对象,负责整个App的消息处理
    private static Looper sMainLooper;  // guarded by Looper.class
    //消息队列
    final MessageQueue mQueue;

//准备Looper对象
 public static void prepare() {
        prepare(true);
    }

    private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        //使用ThreadLocal来给当前线程设置一个Looper对象
        sThreadLocal.set(new Looper(quitAllowed));
    }

    //Application 的主Looper对象,在ActivityThread这个类中调用该方法来生成Looper
    public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {
            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }
}
//获取Application的主Looper对象
 public static Looper getMainLooper() {
        synchronized (Looper.class) {
            return sMainLooper;
        }
    }

    //获取当前线程的Looper对象
    public static @Nullable Looper myLooper() {
        return sThreadLocal.get();
    }

    //获取当前线程的MessageQueue对象
    public static @NonNull MessageQueue myQueue() {
        return myLooper().mQueue;
    }
//从MessageQueue 中取出Message进行分发处理
 public static void loop() {
        final Looper me = myLooper();
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }
        final MessageQueue queue = me.mQueue;

        //...省略代码

        for (;;) {
        //获取Message
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

         //...省略代码
            try {
            //使用Message包含的Handler对象进行消息的处理
                msg.target.dispatchMessage(msg);
                end = (slowDispatchThresholdMs == 0) ? 0 : SystemClock.uptimeMillis();
            } finally {

            }

        //...省略代码
            //回收message
            msg.recycleUnchecked();
        }
    }

从上面可以看出Looper对象的主要责任一个是生成整个Applicaion的主Looper对象，运行在UI线程，这一步是在ActivityThread的main()方法中调用的，如果是在子线程的话也可以生成不同的Looper对象，这样各个线程有属于自己的Looper对象，消息的处理互相不受影响。 
另外就是从MessageQueue中取出Message发送到对应的Handler对象进行处理。 
对于ThreadLocal类的一些分析:Android ThreadLocal及InheritableThreadLocal分析。

Handler

Handler中的关键注释:

Handler有两个主要用途：
（1）安排消息和 runnables将在未来某个点执行; 
（2）在与您自己不同的线程上执行执行消息入队;

其中关键的字段和方法:

public class Handler {

    //通常我们调用该方法来发送消息
    public final boolean sendMessage(Message msg)
    {
        return sendMessageDelayed(msg, 0);
    }
//该方法可以设置消息执行的延迟时间
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) {
        MessageQueue queue = mQueue;
        if (queue == null) {
            RuntimeException e = new RuntimeException(
                    this + " sendMessageAtTime() called with no mQueue");
            Log.w("Looper", e.getMessage(), e);
            return false;
        }
        return enqueueMessage(queue, msg, uptimeMillis);
    }
//最终消息进入MessageQueue的队列
 private boolean enqueueMessage(MessageQueue queue, Message msg, long uptimeMillis) {
     //这里就将handler的引用传递个message对象了
        msg.target = this;
        if (mAsynchronous) {
            msg.setAsynchronous(true);
        }
        return queue.enqueueMessage(msg, uptimeMillis);
    }
//可以进行Runnable任务
    public final boolean post(Runnable r)
    {
       return  sendMessageDelayed(getPostMessage(r), 0);
    }
    //将Runnable任务封装成Message
    private static Message getPostMessage(Runnable r) {
        Message m = Message.obtain();
        m.callback = r;
        return m;
    }
    //处理消息,注意msg.callback和mCallback 的特殊情况,尤其是传入了
    //mCallback 的情况下将不会走handleMessage()方法
    public void dispatchMessage(Message msg) {
        if (msg.callback != null) {
            handleCallback(msg);
        } else {
            if (mCallback != null) {
                if (mCallback.handleMessage(msg)) {
                    return;
                }
            }
            handleMessage(msg);
        }
    }

    //子类必须实现该方法来处理消息
    public void handleMessage(Message msg) {  }
}

总结

消息处理的整个执行流程：

Handler.sendMesasge();
Handler.sendMessageDelayed();
Handler.sendMessageAtTime();
Handler.enqueueMessage(),至此消息入队了;
Looper.loop()从MessageQueue中取出消息，分发给目标Handler;
Handler.handleMessage()
当然中间的一些特殊流程及处理要注意。