Android中的消息处理机制学习笔记

目录

• 简介
• ThreadLocal
• MessageQueue
• Looper
• Handler

简介

消息处理机制应该说基本都用过，因为Android中不允许在UI线程中进行一些耗时的操作，否则就会出现ANR，而将耗时操作放在子线程中运行，运行结束后，子线程需要返回数据给UI线程，但是子线程中是不能直接更新UI线程的数据的，因此就需要子线程将数据法统给UI线程，然后UI线程进行更新，也就是我们一直使用的Handler。

整体的工作流程：在一个线程创建一个Handler，在另一个线程线程中通过Handler将一个Message 发送到创建这个Handler的线程进行处理。
这中间有几点需要注意：
1.创建Handler的线程必须要有一个Looper，否则就会报错，我们平时在UI线程创建的时候UI线程自己已经创建好了Looper，因此我们感觉不到。
2.在调用了Handler的send方法之后，其实是Handler将消息放到了待处理消息的线程的消息队列中，即MessageQueue。每个线程中的Looper都维护着一个消息队列，且一个线程中只有一个，只能本线程访问。
3.线程中的Looper无限循环的读取消息队列，有消息来时就拿出来进行处理，没有就阻塞。
简单的说，线程A创建了Handler，线程B用这个Handler用来发送消息到A的消息队列，A的Looper不断的循环取消息，取出来后A中的Handler进行相应的操作。

消息处理机制主要就是这四部分组成：Handler、Looper、MessageQueue、Message，大致了解了工作流程中之后，下来就分别学习一下每个模块的和原理。

ThreadLocal

这个有必要提一下。
这个类主要是用来存储线程内部的数据的。通过它可以使得线程存储数据，而且只有自己才可以获取到数据，其他线程无法获取，即使不同的线程访问的是同一个ThreadLocal对象。前面提到的Handler在创建的时候就会使用当前线程的Looper构造消息循环系统，那么Handler在创建的时候获取当前线程的Looper就是通过ThreadLocal。使用：通过构造ThreadLocal对象，然后调用set与get方法即可。
set实现原理：
ThreadLocal有一个静态内部类ThreadLocalMap，这个Map的键就是ThreadLocal，值则是我们set进去的一个Object。
这个Map在创建的时候是根据当前线程来创建的。

public void set(T value) {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null)
        map.set(this, value);
    else
        createMap(t, value);
}

在set的时候如果当前线程中不存在Map则进行创建，如果已经存在则将值set进去。
大致的set过程是这样的：ThreadLocalMap中有一个Entry（键是ThreadLocal，值是传入的Object）数组，根据传入的键（ThreadLocal）计算出一个hash值，映射到数组index上，将ThreadLocal作为键value作为值的一个Entry存到数组的index+1上。
有点绕，梳理一下，当每个Thread都用的是一个ThreadLocal，然后根据ThreadLocal为每一个线程都创建一个Map，这个map中存放的是ThreadLocal以及set进去的值。
然后是get方法：

public T get() {
    Thread t = Thread.currentThread();
    ThreadLocalMap map = getMap(t);
    if (map != null) {
        ThreadLocalMap.Entry e = map.getEntry(this);
        if (e != null)
            return (T)e.value;
    }
    return setInitialValue();
}

根据线程获取到map，其中有一个数组，然后根据ThreadLocal获取到数组中的Entry，再获取到其中的值。

MessageQueue

消息队列，主要用于放入消息和取出消息，其中实现的数据结构其实是单链表。主要方法有两个：boolean enqueueMessage(Message msg, long when)和Message next()，分别对应的是入队和出队的操作。
在出队操作中有一个无限循环，如果没有消息，则Looper调用next就会阻塞在这里，一直循环。

Looper

主要扮演的角色就是一直循环从队列里拿消息。
创建Handler的时候需要该线程有Looper，创建Looper的过程：

//创建一个Looper
Looper.prepare();
//开启无限循环
Looper.loop();

另外，如果是自己在子线程中创建的Looper，在使用完毕之后一定要关掉，否则将会无限循环下去。
关闭的方式：在Looper中有以下两个方法：

public void quitSafely() {
    mQueue.quit(true);
}

public void quit() {
    mQueue.quit(false);
}

简单的说就是quit是直接退出，quitSafely则是在队列中的消息都处理完之后退出。
loop方法：
这个方法是一个无限循环方法，唯一的出口就是当队列的next返回了null，也就是在调用了mQueue.quit方法之后才会退出。
然后看一下Looper取出消息之后干了啥：
msg.target.dispatchMessage(msg);
这个msg.target就很容易了，就是前面创建的Handler。
也就是说，取出消息之后，交给了Handler来进行处理。

Handler

首先是Handler的send

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

可以看到，就是将消息入队了。
前面提到，在Looper取出消息的时候，就会交给Handler来处理：

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

终于，看到我们熟悉的handleMessage(msg);了。
那这两个callback又是怎么回事？
msg.callback这个是一个Runnable对象，也就是Handler的传递的参数。
mCallback：

/**
 * Callback interface you can use when instantiating a Handler to avoid
 * having to implement your own subclass of Handler.
 *
 * @param msg A {@link android.os.Message Message} object
 * @return True if no further handling is desired
 */
public interface Callback {
    public boolean handleMessage(Message msg);
}

可以通过这个Callback 来创建一个不需要派生子类的Handler，也就是另外一种创建Handler的方式，一般我们都是继承Handler复写handleMessage。

还有一点，就是创建一个Handler可以通过传递一个Looper来实现，默认创建的时候，我们是获取创建线程的Looper，而这种创建方式就指定特定的Looper，这样的话就可以实现不同的线程中创建的Handler共用同一个Looper，也就是共用消息队列。

主要的核心源码都没有贴，只是大致了解了其实现方式和流程，一方面是篇幅太长了，另外主要就是水平不是特别够，也就了解个大概，后面还需要继续深入学习。