通过源码分析Android 的消息处理机制

     

通过源码分析Android 的消息处理机制

我们知道，Android应用是通过消息来驱动的，每一个进程被fork之后，都会在该进程的UI线程（主线程）中启动一个消息队列，主线程会开启一个死循环来轮训这个队列，处理里面的消息。

通过Android进程的入口 ActivityThread#main 方法可以看到这个逻辑：

    public static void main(String[] args) {

        Looper.prepareMainLooper();

        ActivityThread thread = new ActivityThread();
        thread.attach(false);

        Looper.loop();

    //只要运行正常，都不会执行到这段代码
        throw new RuntimeException("Main thread loop unexpectedly exited");
    }

另外，我们在平时开发中，如果想在子线程中更新UI，必须手动创建一个Looper对象，并且调用它的loop方法：

class TestThread extends Thread {
       public Handler mHandler;

        public void run() {

        // 为当前线程创建Looper对象，同时消息队列MessageQueue也准备好了
            Looper.prepare();

            mHandler = new Handler() {
                public void handleMessage(Message msg) {

            //这里可以更新UI了

                }
            }; 

        // 开始处理消息队列中的消息
            Looper.loop();
        }
}

在这两个过程中，都看到了Looper的身影，因为Looper就是消息队列的管理者，我们调用他的prepareMainLooper和prepare方法，就会为当前线程创建好消息队列，调用looper方法就会开始消息队列的轮询处理过程。

要理解消息处理机制，除了Looper，我们还要理解其他类：

• MessageQueue：消息队列
• Message：消息
• Handler：消息的处理者

UML类图

逐个类分析

Looper

先从Looper开始，上面提到的两个静态方法 prepareMainLooper()和prepare()的作用就是为当前线程创建消息队列，loop()调度这个消息队列。

来看Looper#prepareMainLooper：

 public static void prepareMainLooper() {
        prepare(false);
        synchronized (Looper.class) {

            if (sMainLooper != null) {
                throw new IllegalStateException("The main Looper has already been prepared.");
            }
            sMainLooper = myLooper();
        }
    }

prepareMainLooper是通过调用prepare()方法实现，并且通过myLooper()方法得到了当前线程的Looper，主线程的Looper，就是sMainLooper。

接着看prepare方法：

/**
*  @param uitAllowed 是否允许消息循环退出，在ActivityThread#main 中，我们创建的是主线程的消息循环，肯定不允许退出，其他地方，则可以退出
*/
private static void prepare(boolean quitAllowed) {
        if (sThreadLocal.get() != null) {
            throw new RuntimeException("Only one Looper may be created per thread");
        }
        sThreadLocal.set(new Looper(quitAllowed));
    }

这个方法中为每一个线程new了一个Looper对象，并且设置到sThreadLocal中。sThreadLocal是ThreadLocal类型的变量（线程局部变量），它保证了每一个线程有一个自己独有的Looper对象，

myLooper()：

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

方法很简单，就是返回了当前线程所独有的那个Looper对象。

Looer对象创建好了，同时消息队列也创建好了，接下来就是让整个消息机制跑起来，这就需要通过Looper#loop实现：

    public static void loop() {

    //得到当前线程的Looper
        final Looper me = myLooper();

    //没有Looper对象，直接抛异常
        if (me == null) {
            throw new RuntimeException("No Looper; Looper.prepare() wasn't called on this thread.");
        }

    //得到当前Looper对应的消息队列
        final MessageQueue queue = me.mQueue;

    //一个死循环，不停的处理消息队列中的消息，消息的获取是通过MessageQueue的next()方法实现
        for (;;) {
            Message msg = queue.next(); // might block
            if (msg == null) {
                // No message indicates that the message queue is quitting.
                return;
            }

        //调用Message的target变量（也就是Handler了）的dispatchMessage方法来处理消息
            msg.target.dispatchMessage(msg);

            msg.recycleUnchecked();
        }
    }

首先，得到当前线程的Looper，再通过Looper得到当前线程的消息循环，然后轮询这个消息队列，处理每一个消息，下面我就来看消息队列MessageQueue以及消息Message。

MessageQueue

MessageQueue就是Message队列，消息队列这一数据结构是通过一个Message链实现的，Message对象有一个next字段指向它的下一结点。

public final class MessageQueue {
    Message mMessages;

    //消息队列的初始化，销毁，轮询过程，阻塞，唤醒，都是通过本地方法实现的
    private native static long nativeInit();
    private native static void nativeDestroy(long ptr);
    private native static void nativePollOnce(long ptr, int timeoutMillis);
    private native static void nativeWake(long ptr);
    private native static boolean nativeIsIdling(long ptr);


    /**
    *  把消息加入到消息循环中
        *  @param msg 
    *  @param when 是么时候被执行，在消息队列中会按照时间排序
     */
    boolean enqueueMessage(Message msg, long when) {}

    /**
    *  把消息加入到消息循环中
        *  @param msg 
    *  @param when 什么时候被执行
     */
    boolean enqueueMessage(Message msg, long when) {}

        /**移除消息*/
    void removeMessages(Handler h, int what, Object object) {
}

Message对象放入队列通过enqueueMessage()方法实现，消息的依次获取是通过next()方法实现，其中当获取不到可处理Message对象时，该方法会进入等待状态。

Message

Message就是消息的封装对象，它实现了Parcelable接口，因此可以跨进程传输。

public final class Message implements Parcelable {

    //消息的标识符
    public int what;

    //两个int形的扩展参数
    public int arg1; 
    public int arg2;

    //一个Object拓展参数
    public Object obj;

    //消息发送者的UID
    public int sendingUid = -1;

    //消息带的data
    Bundle data;

    //target对象，也就是处理当前消息的Handler
    Handler target;

    //指向消息队列中下一个消息
    Message next;

    //消息同步锁
    private static final Object sPoolSync = new Object();

    //消息池
    private static Message sPool;

    //消息池大小
    private static int sPoolSize = 0;

    //消息池最大消息数量
    private static final int MAX_POOL_SIZE = 50;
}

对消息的管理是通过一个消息池来实现的，因为消息池的存在，我们在需要创建一个Message对象时，最好使用可复用消息对象的方法来创建它。

正确的使用方法是：

Message msg = mHandler.obtainMessage(WHAT);
msg.sendToTarget();

obtainMessage方法中实际上会调用Message#obtain方法来从消息池中取一个对象。

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 msg = new Message();
msg.what = WHAT;
mHandler.sendMessage(msg);

Handler

Handler 就是消息循环（MessageQueue）中消息（Message）的真正处理者，通过Looper#loop可以看到：

public static void loop() {

        for (;;) {
            Message msg = queue.next(); // might block

            msg.target.dispatchMessage(msg);
        }
    }

Message的target属性就是一个Handler对象，对消息的处理实际上是通过Handler#dispatchMessage方法来处理的，而dispatchMessag方法会调用Handler#handleMessage方法，我们可以重写handleMessage方法 来真正的处理消息的回调。